Emerge & Solve - a GUI framework for Elixir

So far it looks really cool, do you have any examples which showcase most of the available features? What coding agents have implemented the library, what setup was used?

Checkout GitHub - emerge-elixir/emerge_demo: Example showcase app built with Emerge and Solve · GitHub. There is a showcase app in there that covers all of the components and attributes.

I tried lot of models and harnesses in the beginning, settled on Opencode + 5.3Codex, 5.4 later.

So how much, if anything, is written by AI? 90%+, 5%, or 0%?

Sorry, words got lost there, edited. This post is 0% AI. Code is mostly written by AI but it ended up being more of an automatic text editor because I had to have it refactor same thing for 10 times and sometimes I had to do it from scratch in the end. For example there was no way to describe events system that I have imagined to AI, had to give up after hundreds of prompts. In the end it was still a lot faster then doing it by hand. Once there is concrete pattern to follow it can do the remaining 75% of implementation without a problem.

If you have rpi5 check out a demo project for nerves
https://github.com/emerge-elixir/nerves_emerge_demo

You can iterate UI only changes by pasting UI module into IEx shell.
It will require an action that triggers viewport to rerender, for example hitting a + on counter.

That means you can deploy Emerge UI hotfixes using NervesHub on-connect code in production

Solve 0.2.0 is out bringing solve oriented flow for handling general messages to controllers with handle_info/2..5

Emerge - 0.2.1 is out bringing initial support for macOS. Aim for this release is to give macOS users to develop nerves apps easily if you wish to develop proper macOS apps that you can distribute through app store you will have to come up with packaging and signing story. video_target is also not currently support on macOS

If you want to try it out on mac clone GitHub - emerge-elixir/emerge_demo: Example showcase app built with Emerge and Solve · GitHub and run with iex -S mix

Emerge 0.3.1 is out compared to 0.2.1:

• There is initial version of layout caching and renderer cache. Depending on app structure it can bring huge performance improvements especially on animated sections.
• There is now Input.slider
• Size.min/max are now proper size resolution combiners. For example now you can have an element with height(min(content(), fill()) attribute and it will be content sized until content becomes bigger than it’s fill portion. TodoApp in demo now uses it for entries so it grows with entries to screen size and then after that entries become scrollable since entries element has scrollbar_y on it.

Next roadmap:

• Add headless backend, you give it pid and it sends rendered binary to that pid every time there is a change.
• Make all backends automatically fallback to raster rendering in case there is no gpu.
• Add option for output pixel format (HDR displays, 1 bit or 2 bit e ink displays)
• Both of these will be preliminary work for running it on nerves badge/ nerves starter kit. Goal is to have next release run on it

This looks pretty cool. I have also been working on a native GUI framework for elixir and gleam, and ended up with something much closer design-pattern wise to how a lot of elm loops work. So, it’s nice to see a different declarative approach with solve. For nerves, I ended up going with the idea of a remote renderer that could allow connecting over something like erlang SSH or regular SSH over stdio instead of running natively on the device. Gives some interesting possibilities for non-web server UI as well. Curious if you’re using NIFs or a separate process via ports and what your experience with that has been.

My project is called plushie (plushie and plushie_gleam on hex). It started off with the goal of supporting elixir and gleam for both local and remote desktop apps, but it’s taken on a bit of a life of its own and now supports other languages as well. The main thing I’ve been working on is around the renderer and build tooling to allow for custom rust to get mixed into projects similar to how rustler does things. There might be some things I’ve done as part of all that which could be useful to you in your own endeavors. I’m also not convinced that iced is the right underlying GUI library and have been considering something else like gpui-component, but there might be some opportunity here to work toward some common underlying renderer that could be shared between our projects.

Plushie looks interesting. I am not completely sure we can make common underlying renderer on any level higher than skia without making big compromises.

On NIF/port qestion currently I use both:

• On linux it is Rustler NIF, UI declaration is sent to rust using internal binary format called EMRG and rustler sends messages of resolved events to pid setup when starting renderer. If you use it how documentation describes it it will all be setup by viewport.

• On macOS I had to go for different route. macOS host is standalone rust program that is currently started as a port. macOS requires for main renderer loop to be on main thread. So BEAM now spawns macOS hos as a port and communicates with it through unix socket with yet another small internal binary format. It is archited that way so in the future you can have a macOS host start a beam and give it unix socket to have communication with main renderer loop. That will be needed for properly packaging macOS apps for the store. I think iOS will need similar approach, not sure what are Android limitations.

As I plan to rewrite internals before 1.0.0 (possibly multiple times, as it is a bit of a slopfest now) EMRG binary communication can be another layer to target for plushie but that would require plushie to compromise on stack, pin, floating and maybe some other widgets or very awkwardly implement them on top of emerge API. It would require you to implement something like current macOS host for every language. I do plan to add a few more widgets and some kind of canvas API in the future.

Currently EMRG is not very well documented or stable currently, there is overview here and elixir serializer here

I am aiming for performance with Emerge and that requires specific UI description model, as relayouting and caching boundaries. Goal is if you strap a touchscreen onto rpi running nerves ui should be as responsive as last flagship phone that had screen of same refresh rate. If you are running desktop app on 500hz gaming monitor there is no reason for ui not to run smoothly on 500fps (currently still fall a bit short on full page re-renders but I have a plan how to improve performance greatly in the future). And there is no reason for standard GUI app to consume more than 50 MB of CPU ram (looking at you electron apps). Lib size is around 6MB(excluding few system dependencies like gpu drivers and native graphics stack for each platform) for now and I will try to keep it from growing.

We can chat more or hop on a call if you want to discuss bit more.

Theoratically I should be able to render into a VNC server and make remote GUI applications accessible with a standard VNC client, right?