---
url: /docs/getting-started/comparison/noodl.md
description: >-
  Looking for a Noodl alternative? Compare Luna Park with Noodl and its fork
  Fluxscape: node-based logic, backend, code export, hosting, and platforms.
---

# Luna Park vs Noodl and Fluxscape

Looking for a **Noodl alternative**? Luna Park is a visual editor with node-based logic, like Noodl, that builds the interface and the backend of your app, and compiles it into a standard Vue and Node.js application.

Noodl is a node-based low-code editor for web applications. In 2024, it became [open source](https://github.com/noodlapp/noodl) and is no longer managed by its original company. Its development continues in community forks, such as [Fluxscape](https://fluxscape.io), a managed fork with hosting and paid plans. Of all the tools compared here, Noodl is probably the closest to Luna Park: both use **node graphs** instead of lists of actions.

## At a glance

### Building

| | Luna Park | Noodl / Fluxscape |
|---|---|---|
| **Interface** | Component tree, CSS-based styling, design tokens | Visual nodes for UI elements, styled in the property panel |
| **Logic** | Visual scripting graphs, typed data | Node graphs, JavaScript function nodes |
| **Execution** | Compiled to JavaScript and Vue | Noodl runtime, shipped with your app |
| **Extensibility** | npm packages, TypeScript functions, plugins | JavaScript nodes, custom modules |
| **AI** | Sidekick, external agents through MCP | Depends on the fork |

### Data and backend

| | Luna Park | Noodl / Fluxscape |
|---|---|---|
| **Backend** | Built-in: routes, crons, PostgreSQL | Cloud services (self-hosted or managed), Supabase in Fluxscape, any REST API |
| **Database** | PostgreSQL: joins, aggregates, transactions | Collections of records ("classes") in the cloud services |
| **Server logic** | Visual, same graphs as the interface | Cloud functions |

### Ownership and costs

| | Luna Park | Noodl / Fluxscape |
|---|---|---|
| **Editor** | Commercial, actively developed | Open source (GPLv3 editor, MIT runtime) ([source](https://github.com/noodlapp/noodl)) |
| **Code export** | Readable Vue + Node.js code | Deployed app built on the Noodl runtime |
| **Hosting** | Anywhere | Self-hosted, or Fluxscape hosting |
| **Pricing model** | Fixed subscription | Free (community), paid plans on Fluxscape |
| **Platforms** | Web (single-page app, PWA), desktop (Windows, macOS, Linux), mobile (Android, iOS) | Web |

::: info
This comparison reflects our understanding of Noodl and Fluxscape as of October 2026. Community projects evolve fast: check [the Noodl repository](https://github.com/noodlapp/noodl) and [fluxscape.io](https://fluxscape.io) for their current state.
:::

## Where Noodl and Fluxscape are stronger

* **Open source**: the editor and the runtime are free to use, modify, and self-host.
* **One paradigm for everything**: in Noodl, UI elements are nodes too, so the interface and the logic live in the same graph.
* **Existing projects**: if your app is already built with Noodl, a fork such as Fluxscape keeps it running without a rewrite.

## Where Luna Park is stronger

### Compiled code, not a runtime

A Noodl app is deployed with the Noodl runtime, which runs your node graphs in the browser. Luna Park is a **compiler**: each node of a graph becomes a line of JavaScript, and each component becomes a regular Vue component. The [exported](../../deployment/compilation) application is plain Vue and Node.js code, readable by any developer, with no Luna Park runtime.

### A backend in the same language

In Noodl, server logic lives in cloud functions, attached to a separate backend service. In Luna Park, [routes](../../fundamentals/data/routes), [crons](../../fundamentals/data/cron), and [authentication](../../fundamentals/data/auth) are part of the project, built with the same visual scripting as the interface, and the same [types](../../fundamentals/logic/scripts#type-files) describe your data on both sides.

### A real SQL database

Luna Park's [database](../../fundamentals/data/database) is PostgreSQL, in the editor and in production. A single query can join tables, group rows, and compute counts, sums, or averages, and a [transaction](../../fundamentals/data/database#specialized-nodes) saves several changes at once or none at all. A route runs on the same server as the database and talks to it directly.

### Typed logic

Luna Park graphs are typed: each anchor shows the type of the value it carries, and links only connect [compatible types](../../fundamentals/logic/visual-scripting/graph). [Type files](../../fundamentals/logic/scripts#type-files) describe the shape of your data once, and the same types are shared by the interface and the backend.

### The web ecosystem

Luna Park uses [npm](../../integrations/npm): the functions of any package become nodes, and Vue component packages add components. You can also write [TypeScript functions](../../fundamentals/logic/scripts#code-functions) and [plugins](../../plugins/introduction).

### Every platform from the same project

From a single project, Luna Park exports a single-page web app, a PWA, and, with the [desktop app](../desktop-app), native apps for Windows, macOS, Linux ([desktop](../../deployment/desktop)), Android, and iOS ([mobile](../../deployment/mobile)).

## Things to know before switching

* **Luna Park is not open source.** The editor is a commercial product, and downloading the source code of your app requires a paid plan (see [Plans](../quick-start#plans)). The exported code is yours.
* **No automatic import.** Noodl projects cannot be imported: you rebuild the app in Luna Park. The node-based approach makes the concepts familiar.
* **Interface and logic are separate.** In Luna Park, you build the interface in the component tree and the logic in graphs, instead of placing UI elements as nodes.
* **You host the backend.** Routes, database, and crons run on your own server (see [Self-hosting](../../deployment/deployment)).

## From Noodl concepts to Luna Park

| Noodl | Luna Park |
|---|---|
| Page | [Page](../../fundamentals/interface/components#pages) |
| Component | [Component](../../fundamentals/interface/components) |
| UI nodes (Group, Text, Button...) | Elements of the component tree |
| Logic nodes | Nodes of a logic graph |
| Variable / Object nodes | [Variable](../../fundamentals/logic/variables), or [Store](../../fundamentals/logic/store) for global state |
| Function node (JavaScript) | [Function](../../fundamentals/logic/scripts) (graph or TypeScript) |
| Cloud function | [Route](../../fundamentals/data/routes) |
| Class (cloud data) | [Database](../../fundamentals/data/database) table |
| REST node | `Fetch` node |
| Styles | [Design tokens](../../fundamentals/interface/styling#design-tokens) |

## Which one to choose?

**Choose Noodl or Fluxscape** if an open-source editor is a requirement, or if you already have a Noodl project you want to keep running.

**Choose Luna Park** if you want node-based logic in an actively developed tool, with a PostgreSQL backend in the same project, compiled code that you own, and native apps from the same project.
