Desktop · Windows, macOS, Linux
A visual IDE for algorithms and code
FalangSketch is an offline app where you think in flowcharts instead of syntax. Draw an algorithm once and get compilable code in several languages at once. No account, no server, no cloud.
How it works
Conditions, loops and functions are blocks on a canvas. Click a line to add a step, drag to move, Ctrl+Z to undo.
Structures, enums and external APIs become types the editor checks in every expression.
One command generates code for every target language — each into its own folder in your project.
One diagram, five languages
The logic constructor type-checks every expression with the real TypeScript compiler and generates readable code. Switch the tabs: the diagram on the left stays the same.
double discount(double total, bool isVip) {
double rate = 0;
if (total >= 5000) {
rate = 5;
}
if (isVip) {
rate += 10;
}
double price = total * (100 - rate) / 100;
return price;
}func discount(total float64, isVip bool) float64 {
rate := 0.0
if total >= 5000 {
rate = 5
}
if isVip {
rate += 10
}
price := total * (100 - rate) / 100
return price
}pub fn discount(total: f64, isVip: bool) -> f64 {
let mut rate = 0.0;
if total >= 5000.0 {
rate = 5.0;
}
if isVip {
rate += 10.0;
}
let price = total * (100.0 - rate) / 100.0;
return price;
}public static double Discount(double total, bool isVip) {
double rate = 0;
if (total >= 5000) {
rate = 5;
}
if (isVip) {
rate += 10;
}
double price = total * (100 - rate) / 100;
return price;
}export function discount(total: number, isVip: boolean): number {
let rate = 0;
if (total >= 5000) {
rate = 5;
}
if (isVip) {
rate += 10;
}
const price = total * (100 - rate) / 100;
return price;
}FalangSketch
From a rough algorithm sketch to code that compiles even on a microcontroller.
Editor
The main path always runs top to bottom, branches go to the right. The editor lays blocks out for you and won’t let you draw a broken construct, so even a big algorithm stays readable.
Text projects
Text projects draw algorithms in plain language — instructions, procedures, plans. A silhouette splits a big process into branches like chapters, and a tree turns ideas into a mind map.
Three project types
Algorithms in plain language: functions, process silhouettes and mind maps with formatted text.
Typed logic with structures, enums and external APIs — with code generation for 5 languages.
A diagram whose blocks hold ordinary, syntax-highlighted code. Unchecked — for sketches and documentation.
FalangSketch
Describe a change in words — the agent edits diagrams with the same actions you use. Works with any OpenAI-compatible model.
Every project folder gets a ready MCP config: an agent in your terminal reads, edits and validates diagrams.
Named versions, side-by-side comparison highlighted on the canvas, one-click restore.
Each diagram on its own sheet, sized automatically from A4 to A1.
Projects from the previous Falang version are converted automatically on first open — with a backup.
Switch the interface and menu language on the fly.
FalangSketch
An algorithm is understood by eye first. The diagram shows the logic, the generated code shows what it looks like in a real language.
Describe business logic once as a diagram and get it in C++, Rust or Go — down to no_std firmware for a microcontroller.
Procedures and processes as diagrams anyone can read without training, printed on sheets up to A1.
FalangSketch
Nothing: the app is free and open source under the AGPL-3.0 license.
No. The app works fully offline and projects are plain files on your disk. Only the AI agent needs internet — if you choose to set it up.
Ordinary, readable source code: one file for C++, Go and C#, one file per diagram for TypeScript and Rust. Expressions are checked by the TypeScript compiler, and the editor only offers what every target language supports.
Yes: a project is a folder of JSON diagram files named after the diagrams. The app’s version history works on top of git as well.
FalangSketch is free, needs no sign-up and works offline.
Falang
Automation you can see
Bots, CRMs, payments and marketplaces as diagrams that read like instructions. Durable execution on Temporal, 84 integrations and an AI agent that builds the process from a description.
Arduino without fighting C++ syntax
Draw setup() and loop() as diagrams, drive pins and sensors with ready-made blocks, flash the sketch to a board and debug it right on the hardware.