In this blog post, I’ll walk you through the very first steps of building Parsifly, the main challenges I’ve faced so far, and the technical decisions that laid the foundation. This is the first article in a series that will document the entire journey. If you’re interested in low code tools, web development, or want to follow the creation of a real project from scratch, keep reading.
Why create another low code platform?
After testing many tools in the low code ecosystem, one problem stood out: most platforms don’t allow developers to easily extend their functionality. And when they do, it’s often overly complex, poorly documented, or tightly coupled to internal APIs.
Parsifly takes a different approach from the very beginning. The goal is to allow any developer to build custom extensions in TypeScript and seamlessly add them to the platform. These extensions will be able to add buttons, actions, visual components, code parsers — anything that improves or expands what the tool can do.
First step: Project setup with React + Vite
Since Parsifly is a SPA (Single Page Application) and doesn’t require a backend at this stage, the best fit was React with Vite. It’s fast, modern, and perfect for building frontend-heavy applications.
The initial setup already includes:
Tailwind CSS v4 (next version) for rapid and flexible styling using utility-first classes.
Custom ESLint config to keep the codebase consistent and readable.
Theme configuration with primary color, background, borders, and separator tokens defined up front to keep the design process efficient and standardized.
VS Code-inspired interface layout
The UI layout is heavily inspired by Visual Studio Code. The structure includes:
A left sidebar for file management.
A center panel for the visual builder.
A right sidebar for editing properties of selected components.
A header and footer similar to VS Code's status bar and command area.
This familiar layout will help developers onboard quickly and feel at home within the tool.
Extension support: The core of Parsifly
The defining feature of Parsifly is its native support for extensions. From the very beginning, we’re building a system that allows:
Adding new parsers to export projects in any language or framework.
Creating new global actions, buttons, and visual widgets.
Dynamically updating the UI through extension manifests.
Empowering the community to build tools that go beyond what’s available out of the box.
Example: JSON export extension
The first working extension exports the current project as a .json file. A simple “Download” button triggers this export. While basic, this already proves the extensibility concept — the same mechanism can later be used to export to JavaScript, HTML, Flutter, and much more.
Web Worker communication with Comlink
One technical hurdle we had to overcome was enabling safe, efficient communication between the main React UI and Web Workers, which are used to isolate logic-heavy extension processing.
Normally, talking to a Web Worker requires clunky postMessage and event handling. To make this much cleaner, we’re using Comlink — a library that abstracts this message passing into clean, async functions. It makes two-way communication between the UI and the worker simple and scalable — perfect for our extension architecture.
Extension manifests and registration
Each extension in Parsifly is defined through a manifest.json file. This manifest contains:
The extension name
Available parsers
Global actions and buttons
Any custom UI elements
When a new extension is loaded, the platform parses this manifest and automatically injects its functionality into the interface — no rebuild required.
What’s already working (and what’s coming)
We’re still early in development, but here’s what’s already been prototyped:
A drag-and-drop UI builder for placing components visually.
A logic flow builder, also with drag-and-drop support.
A component property editor for setting labels, IDs, events, etc.
A working JSON export extension.
A dynamic layout and UI inspired by Visual Studio Code.
A basic extension system already operational.
Want to get involved?
Parsifly is a project built by devs, for devs. If you have ideas, feedback, or want to see a specific parser or feature included — drop a comment or suggestion.
In the near future, we’ll release a testing version where you can build and run your own extensions directly inside the platform.
Support the creation of this series
This is the first post in an ongoing devlog series that will follow the evolution of Parsifly. If you like the idea and want to support this journey:
Like the YouTube video that accompanies this post.
Leave a comment saying “I want more” to show your support.
Share with other developers or teams interested in low code platforms.
The next video will only be produced if we hit 50 likes, so your feedback and engagement are essential!
Conclusion
Parsifly’s mission isn’t to reinvent low code — it’s to open it up. By supporting extensions from the start, we empower developers to tailor the platform to their needs instead of being stuck with rigid tools.
If you’ve ever wanted to build a visual UI editor, a logic designer, or your own export tool for a specific tech stack — Parsifly will be the perfect playground.
More updates coming soon. Stay tuned!