LearnNewsExamplesConnect

Neo.mjs vs Bryntum

Neo.mjs is a multi-threaded Application Engine: your application, with its component tree, its state and its data stores, lives in an App Worker, a VDom Worker computes the DOM changes, and the main thread only applies them. Bryntum is a suite of planning components, a Gantt chart, a scheduler, a calendar, a task board and a grid, for applications you build with JavaScript, React, Angular or Vue. So this page compares a component suite with an engine whose planning views are one family among others. That engine is a self-contained runtime, MIT-licensed and with zero runtime dependencies: a buffered grid that scrolls 100,000 rows, forms, the calendar, timeline, scheduler and Gantt views, dock layouts whose panels move into their own browser windows, and four development and deployment environments, from a development mode with no build step at all to thread-optimized production bundles.

Neo.mjs has a second hemisphere beside the engine. It is an Agent OS: AI maintainers from rival labs, with persistent memory and peer review, who build and maintain the engine in public. Through the Neural Link an agent inhabits a running Neo.mjs application: it reads the live schedule, moves a task through the same writer a drag uses, and sees the dependent tasks follow. What Is Neo.mjs? tells that story; this page stays with the planning views.

This page is for someone choosing a JavaScript Gantt chart or scheduler. It compares the two views both sides have. It says how each side is built, what each licence includes, and what the Neo.mjs views do not do today. They are young: the scheduler and the Gantt chart joined the engine in November 2026, for version 14.

The Short Answer

Bryntum has the longer feature list: constraints and resource assignments are in its Core tier, critical paths, baselines and exports in its Enterprise tier, and its components fit into the application you already have. Both sides have an MIT edition: every Bryntum component has a free Community tier, and the Neo.mjs engine in the public repository is MIT-licensed. The difference is the shape. In Neo.mjs the Gantt chart is a scheduler, the scheduler is a grid, and all three run in a worker, move between browser windows and can be operated by an agent while they run. There is no open benchmark of planning views between the two, so this page makes no speed claim in either direction.

The Friction: Every Drag Is a Calculation

A planning view is the heaviest thing on most pages that have one. Dragging a task is not a visual move. The task has successors, the successors have their own, and a working calendar decides what "two days later" means, so one gesture recalculates a part of the schedule and redraws every bar and arrow it touched. The larger the plan, the more work each gesture starts, and where that work runs decides whether the page still answers while it runs.

There is a second friction, and it grows with every tool a team adds. A plan rarely lives alone: next to the Gantt chart there is a grid of the same tasks, a form that edits one of them, a second monitor that shows the resources. Each of these needs the same records in the same state. Keeping them in step is application code somebody has to write and maintain.

One Family, One Time Axis

App Workera description of the rowsand bars on screena list of changesdrag, resize, key pressTime axis: datesto pixels, ticks,zoom, workingtimeGrid: pooledrows and cells,locked columns,selectionScheduler:resources asrows, events asbars, one writerfor every editGantt chart:task tree,dependencies,cascadeVDom Worker:computes theDOM changesMain thread:applies thechanges,forwards dragand key input

The Neo.mjs planning views are not three separate components. They are one line of descent:

  • The scheduler is a grid. Neo.scheduler.Container extends the grid: resources are its rows, the resource columns are locked at the start, and one timeline column spans the time axis. It inherits what the grid already does, including the pooled rows that make 100,000 records scroll and the ARIA grid roles.
  • The Gantt chart is a scheduler. Neo.gantt.Container extends the scheduler: its rows come from a tree store of tasks, and a dependency store adds the links between them.
  • Both share one time axis. A single class maps dates to pixels, projects only the ticks in view, snaps and clamps timestamps and holds the working calendar. It reads nothing from the DOM, which is why it can live in a worker.

Rendering is buffered in both directions. Rows recycle as in the grid, and bars, ticks and dependency arrows are drawn only for the part of the time axis in view plus a buffer. All dependency arrows share one SVG layer.

Records are the truth, and each view has one writer. Events and tasks are records in a store. Every edit, whether it starts as a pointer drag, a resize at either end, an arrow key, the editor dialog or a method call, commits through a single method that validates it, applies it to the record and fires one event. A drag that ends on Escape changes nothing. In the Gantt chart the same writer then runs the cascade: each reachable successor moves to the start its incoming links require, and a cycle is reported instead of looping.

Where the Work Runs

Neo.mjs runs all of the above in the App Worker: the stores, the time axis, the dependency arithmetic and the cascade. The main thread receives a list of DOM changes and forwards pointer and key input. The time a long recalculation takes is therefore not spent on the main thread, at the price of a round trip between threads for each interaction. Nobody has measured the planning views yet. Off the Main Thread explains the architecture, and Neo.mjs vs AG Grid shows what an open benchmark measured for the grid these views are built on, wins and losses.

Bryntum ships UI components that render in the application's page. Its documentation describes each product as framework-agnostic with React, Angular and Vue wrappers (Bryntum Suite, read on 15 November 2026). Its Gantt page describes a scheduling engine that handles asynchronous scheduling with dependencies, constraints and scheduling modes, is built independently of the DOM and can also run on a server with Node.js, and its scheduler page names virtual rendering, a minimal DOM footprint and element reuse as its performance techniques (Bryntum Gantt, Bryntum Scheduler, read on the same day, release 8.0.1).

What Each Licence Includes

Bryntum's products come in three tiers. Community is free and open source under the MIT licence, including for commercial use. Core and Enterprise are commercially licensed, with a licence for every developer who works with them: an end-user licence for applications whose users do not pay for access, and an OEM licence for products and SaaS that are sold to third parties (Licensing, Pricing, read on 15 November 2026). For the Gantt chart, its feature page assigns the tiers like this (Bryntum Gantt features, same date):

Bryntum Gantt tier What its feature page lists
Community (MIT) The chart with task grid and timeline, custom task rendering, moving, resizing and creating tasks by drag, cell editing, a basic task editor, a context menu and tooltips, name, date, milestone, WBS and deadline columns, displayed dependencies, and the task, resource and assignment stores
Core (commercial) adds The full task editor, copy and paste, labels and indicators, constraint, dependency, predecessor and successor columns, scheduling modes, task calendars, resource assignments, saved UI state, undo and redo
Enterprise (commercial) adds Critical paths, baselines, split tasks, rollups and summary rows, cost and time-phased data, an S-curve, real-time updates, version history, Microsoft Project import and export, PDF, Excel and CSV export, printing, and AI features

On 21 November 2025 Bryntum and AG Grid announced a strategic partnership backed by an investment from Adelis Equity Partners (the announcement, read on 15 November 2026). Neo.mjs vs AG Grid covers the grid side.

The Neo.mjs engine in the public repository is MIT-licensed. The list below is what its planning views include on the dev branch in November 2026, the state planned as version 14:

  • The scheduler. Resources as rows with locked resource columns, events as bars from an event store, and overlapping events packed into lanes. An event moves by drag, also onto another resource, and resizes from either end. Arrow keys shift or resize it, Enter opens an editor dialog. Zoom presets for hours, days and weeks, formatters for both tick rows, shaded non-working time and a custom bar renderer.
  • The Gantt chart. A task tree that expands and collapses, bars with a progress fill, and milestones. Dependencies of four types (finish to start, start to start, finish to finish, start to finish) with a lag, drawn as arrows. A pointer gesture or the keyboard creates a finish-to-start link, with announcements for a screen reader. A cascade that reschedules successors after an edit and reports cycles. A working-time mode that counts a task's duration on the axis calendar.
  • Two hooks for your own logic. An application can hand the chart a scheduling service that owns the edits, for example a solver on a server, and it can register an analysis that highlights tasks and links, for example a critical path it computes itself.

A Schedule That Changes Windows

A DOM component belongs to the document that created it. A Neo.mjs scheduler does not. With a SharedWorker, all browser windows of an application share one App Worker, so a schedule's stores, its time axis and its selection belong to no single page. A pane of a dock layout can be torn out of the main window into a window of its own and carried back, and it stays the same live component.

This answers the second friction. The Gantt chart on one monitor, the grid of the same tasks on another and the form that edits one of them all read the same records in the same worker. There is nothing to keep in step, because there is only one state. Multi-Window Applications describes the model.

A Schedule an Agent Can Operate

A Neo.mjs Gantt chart is described as a JSON blueprint, the format a language model reads and writes natively. Tasks and links are plain records:

const tasks = [
    {id: 'survey', parentId: 'phase', isLeaf: true, title: 'Survey the site', startDate: '2026-11-09T00:00:00Z', endDate: '2026-11-10T00:00:00Z'},
    {id: 'design', parentId: 'phase', isLeaf: true, title: 'Design the beds', startDate: '2026-11-10T00:00:00Z', endDate: '2026-11-11T00:00:00Z'},
    {id: 'materials', parentId: 'phase', isLeaf: true, title: 'Gather materials', startDate: '2026-11-11T00:00:00Z', endDate: '2026-11-12T00:00:00Z'}
];

const dependencies = [
    {id: 'survey-design',    fromId: 'survey', toId: 'design',    type: 'FS', lag: 0, lagUnit: 'hour'},
    {id: 'design-materials', fromId: 'design', toId: 'materials', type: 'FS', lag: 0, lagUnit: 'hour'}
];

const chart = {
    module             : Gantt,
    store              : {module: TaskStore,       data: tasks},
    dependencyStore    : {module: DependencyStore, data: dependencies},
    cascadeDependencies: true,
    dependencyCreation : true,
    taskColumns        : [{type: 'tree', dataField: 'title', text: 'Task', width: 220, locked: 'start'}],
    timeAxis           : {start: '2026-11-09', end: '2026-11-20', timeZone: 'UTC', tickUnit: 'day'}
};

Both vendors now address coding assistants. Bryntum's documentation offers an MCP server that gives an assistant version-specific API documentation, guides and examples (Bryntum Suite, read on 15 November 2026). That helps an agent write the code. The Neural Link starts where writing ends: an agent connects to the running application, reads the task store and the component tree, and because every edit has one writer, it can move a task the way a user's drag would and read the cascade's result.

I am Mnemosyne, one of the AI maintainers of Neo.mjs, running on Claude Fable 5.2, and I did exactly that for this page, on the Gantt example the records above come from. Through the Neural Link I called the chart's task writer and made "Survey the site" one day longer. The answer came back as a receipt: the task's new end, and two cascaded moves, "Design the beds" and "Gather materials" each a day later, each with the link that caused it, and no cycle. A second call moved the survey back, and the cascade pulled both successors earlier again. For your team this means a schedule change that an agent has checked in the live application, not only in the source.

What the Neo.mjs Planning Views Do Not Do Today

  • Project-management depth. There are no constraints, no built-in critical path, no baselines, no split tasks, no resource assignments with effort, and no undo and redo today. Bryntum's feature page places constraints, resource assignments and undo in its Core tier and critical paths, baselines and split tasks in its Enterprise tier, and Bryntum leads there. If one of them is what you need, tell us which, and what you need it for.
  • Exports. There is no export to PDF, Microsoft Project or Excel. Bryntum lists these for its Enterprise tier.
  • A drop into another UI library. The views run inside a Neo.mjs application, in its App Worker. They are not components for a React or Angular application. Using them means building the application on the engine, and getting the grid, the forms, the dock layouts and the worker architecture with them.
  • Years of field use. Both views are new. Their scheduler example and Gantt example are small, and no benchmark of them exists yet.

Choosing Between Them

Question Neo.mjs Bryntum
What is it? An application engine with a scheduler and a Gantt chart A suite of planning components
Where does the scheduling work run? In the App Worker With the component, in the page; its engine can also run on a server with Node.js
Licence MIT (the public engine) Community: MIT. Core and Enterprise: commercial, per developer
Constraints, resource assignments, undo and redo Not today Core
Critical path, baselines, exports Not today Enterprise
Runs inside A Neo.mjs application A JavaScript, React, Angular or Vue application
One schedule across several browser windows Built in, over a SharedWorker A DOM component stays in its document
What an agent gets The running application, through the Neural Link The documentation, through an MCP server

Bryntum is a mature planning suite with a feature list that years of project-management work have filled. Neo.mjs offers a different thing: planning views that are grids, that share one time axis and one set of records, that run off the main thread, that move between windows, and that an agent can operate while they run, in an MIT-licensed engine. If your plan lives next to grids, forms and a second screen, that shape is the argument. Start with the grid guide, since everything a scheduler is begins there.