Help write a compiler
that changes what's possible.
Morph is a framework that turns your code into a native desktop app — no browser, no Electron. Write your UI with web tools you already know, and ship a fast, lightweight app with OpenGL rendering. It was started by a single author who refused to accept that this didn't exist. It can't be finished by one person. That's where you come in — and why your contribution helps Morph grow.
Why contribute to Morph?
This isn't another open-source project looking for free labor. Morph is a chance to help build something that genuinely doesn't exist yet.
Help a real framework grow
Morph turns your code into fast, lightweight native desktop apps — no browser, no Electron. It's early and full of opportunity. Every contribution helps it grow into something thousands of developers rely on.
Build the future of native apps
There's no mainstream framework that gives you the web developer experience while shipping true native desktop apps. Morph is building that — and it needs people who want to be part of shaping it from the ground up.
Your skill makes a real difference
Whether you're strong at rendering, layouts, docs, examples, or testing — there's a place for you. Small, focused contributions add up quickly and get reviewed fast.
Early-stage, real impact
Every contribution lands at the architectural layer — the design decisions you help make will define how developers ship native apps. Your name goes on something real, and your work directly helps Morph grow.
What exactly is Morph?
Morph is a compiler-based native UI framework. You write your UI with JSX and CSS (including Tailwind), and Morph compiles it into a standalone native binary — no browser, no Electron, no WebView.
Rendering is powered by OpenGL 3.3+ for GPU-accelerated drawing and sub-millisecond frame times, with zero runtime dependencies and a binary under 1 MB thanks to dead-code elimination.
The toolchain is written in Rust. The compiler binary, morph (crate morphc), is a single, fast binary compiled with cargo build --workspace, parsing JSX/TSX with Oxc and CSS with lightningcss, lowering to a typed IR, and emitting C++ (with a future Rust runtime).
The dev experience mirrors the web: morph dev watches your files, recompiles only the logic layer, and pushes IR over loopback TCP to the running window — hot-swapping the new logic.so via dlopen. The window never restarts.
A Rust workspace built for contributions.
The whole compiler is one Cargo workspace. Pick a crate that matches your interests — each has a clear job.
The `morph` command — new, install, update, dev, build, run, check, doctor, cache, plus direct file morphing (`morph app.ts --to cpp|rust`). clap-based CLI, version management, hot-reload over loopback TCP.
Intent-based codegen: escape analysis picks stack, unique_ptr, or shared_ptr, with native types (int32_t, std::string) by default and --type strict for Js* wrappers.
Global cache under ~/.morph/cache — versioned C++ runtimes, remote CSS and @font-face files, fingerprints for incremental builds.
Oxc (3x faster than SWC, arena-allocated, spec-compliant) for JSX/TSX, lightningcss for CSS. Typed ASTs that feed the rest of the pipeline.
The typed IR that sits between parsing and codegen. Style registry, Tailwind resolution, IRBuilder — JSON IR wire format shared with dev mode.
Tera templates that emit C++ (and a future Rust runtime). Feature flags, node/logic emitters, dead-code elimination.
Cross-platform builds via g++/clang++, binary output, and the .morph/build directory structure.
morph.config.json, morph.lock, runtime versioning and compatibility checks.
Real bugs, waiting for you.
The author is upfront about it: Morph is buggy. A found bug is half-fixed.Here's the honest list — pick one and make it disappear.
Every flex child sits at double its left/top margin — rows drift sideways line by line
`flex-grow` centering reads a stale total and lands the whole row off-center
Lines that should wrap don't — the wrap test forgets the gap
`margin: auto` centers against a size clamped after centering
Text ignores its own padding — first glyph inside the gutter
Font inheritance reaches only one level deep
Emoji measure with the text font but draw with the emoji font
Hot reload drops a save if one is already running
Conditional rendering `{cond ? a : b}` leaks both branches' nodes on every save
Signals are read across threads without synchronization where fetch() resumes
Didn't see a bug you've hit? File an issue — a report is a contribution too.
Where you can make a difference.
Every part of Morph needs help. Pick what matches your skills.
Compiler & Tooling
AdvancedMorph's toolchain needs contributors to keep improving how quickly and reliably your code turns into a native app. Help with performance, hot reload, error messages, and build quality.
Layout & Rendering
AdvancedThe C++ runtime and OpenGL renderer — Flexbox layout, text shaping, CSS animations, and the compositing pipeline. The layout engine has real, named bugs listed below.
Docs, Story & Examples
BeginnerMorph's docs tell the real story of why it exists. Write tutorials, build example apps, expand the docs in the repo, and add architecture explainers.
Bug Reports & Testing
BeginnerMorph is honest about being buggy — and a found bug is half-fixed. Confirm issues, write tests, squash bugs, and make the framework solid.
Platform & Tooling
IntermediateExpand Morph's reach and the developer experience around it: Linux/macOS/Windows support, CI/CD, package distribution, and editor tooling.
Get started in minutes.
Four steps from zero to your first pull request — clone, build, fix, ship.
Clone the repo
Everything lives in the single Levizr/morph repository — no separate repos to hunt for.
git clone https://github.com/Levizr/morph.git
cd morphBuild the Rust workspace
The entire toolchain is Rust — one Cargo workspace, no Python to install. Build everything, then verify your C++ toolchain and graphics libs with morph doctor.
cargo build --workspace
target/debug/morph doctorFind what needs a hand
Pick an open issue, or dive straight into one of the crates above. The bug list below is full of places to make an immediate difference.
Submit a PR
Run cargo fmt and the workspace tests first, keep PRs focused to one fix or feature, and open the pull request. The maintainer reviews quickly.
cargo test --workspace
git checkout -b my-feature
git commit -m 'feat: add X'
git push origin my-featureGuidelines that keep Morph healthy.
Code quality matters
Write clear, readable code and follow the existing patterns in the codebase. Rust must be `cargo fmt` clean with no new warnings; C++ runtime headers stay header-only.
Explain your reasoning
In your PR, explain why the change is needed, not just what it does. Context helps reviewers approve faster.
Test what you change
Add tests when possible — `cargo test --workspace` plus the morpher fixture tests. For rendering and layout changes, include before/after screenshots or reproduction steps.
Keep PRs focused
One logical change per PR. Small, reviewable PRs get merged faster than sprawling 500-line diffs.
Be kind and constructive
A community that respects each other builds better software. Feedback is about the code, not the person.
It was never going to be built
by one person alone.
A 17-year-old built every line so far — the parser, the compiler, the renderer, the layout engine. He asked for help openly and honestly. Be the person who answers that call. A found bug, a fixed flex rule, a finished crate — it all adds up.