Sometimes development gives you a perfect timing moment.
I had just tagged and pushed a release... and exactly in that moment the
system told me I had reached the usage limit. Right after the push. Not
before.
That screenshot felt like a small 🎯 bullseye moment.
But the interesting part is not the timing.
The interesting part is the technology behind the project.
A different idea of Android development
In my current project I am experimenting with a scripting language
called SMS (Simple Multiplatform Script).
The idea is simple:
Build a language that feels like scripting, but runs native.
Native compilation
Normally the code is compiled through LLVM IR.
That means the result runs native on Android, not inside a VM.
So compared to many typical setups:
- no virtual machine
- no visible memory management
- no manual
malloc/free
- no garbage collector
LLVM handles the low level details under the hood.
From the developer perspective it feels like writing a script.
Runtime Code via HTTP
Another interesting aspect is how dynamic code is handled.
When code is shipped with the application, it is compiled to native code via LLVM.
However, code that is loaded dynamically via HTTP is executed inside a sandbox and interpreted at runtime.
This makes it possible to extend or modify application behavior without rebuilding the app.
Hot reload during development is just one side effect of this architecture.
The same mechanism can also run safely in production.
Type inference instead of declarations
Another design choice:
The user does not need to declare types.
Types are inferred automatically when values are assigned.
Example idea:
var number = 42
var pi = 3.14
value → type is derived automatically.
So the language keeps the simplicity of scripting while still
producing native code.
Hot Reload via Interpreter
But there is another layer that makes things interesting.
When code is loaded dynamically over HTTP, it is not compiled first.
Instead it is interpreted immediately.
That enables Hot Reload.
Which means:
You can push new code and the running Android app updates its behavior
instantly.
No rebuild.
No reinstall.
Why combine both approaches?
Because each approach has advantages.
Compiled mode
- maximum performance
- native execution
- optimized code
Interpreter mode
- dynamic updates
- hot reload
- instant experimentation
Combining both gives a workflow that feels extremely powerful.
Error feedback - Amiga 500 style
When SMS code fails, the app does not crash silently.
It tells you exactly what went wrong.
If you grew up with an Amiga - you know this feeling.
Except this time the error message is actually useful and you can continue - without scripts running.
The result
An Android development environment that feels like this:
- scripting speed
- native performance
- dynamic updates
- simple syntax
For me personally, this feels like a very interesting direction for future tooling.
The bigger idea
This language is also part of a broader ecosystem:
- SML (Simple Multiplatform Language) for UI and structure inspired by QML from Qt, but without the expressions.
- SMS a Kotlin like language for logic
- Forge4D Multiplatform Dev Environment based on Godot 4.6
The goal is simple:
Make software development more accessible, without sacrificing
performance.
Current capabilities
At the moment the runtime already provides several building blocks.
UI elements are described with SML (Simple Multiplatform Language).
This currently includes:
- dialogs
- standard controls
- layout structures
Content can also be rendered using Markdown, which makes it easy to build documentation (like in the web stack), books or content-driven apps.
On top of that the runtime exposes a 3D scene powered by the
Godot 4.6 engine.
This allows loading and animating .glb models directly inside the app.
So the platform can already combine:
- structured UI (SML)
- rich text content (Markdown)
- interactive 3D scenes (SML, GLB)
And yes... the release timing was perfect 😄
Sometimes the universe just gives you a small developer joke.
Push release → success → usage limit reached.
(So even the Claude abo for just 20,- € helped)
Perfect timing.