Gantt Overview

RevoGrid Gantt is an Enterprise plugin layered on top of the base grid. RevoGrid owns rendering, virtualization, editing, and keyboard interactions. Gantt adds task timeline projection, dependency links, scheduling rules, resources/assignments, critical path, baselines, and timeline tools.

Source code

TypeScript ts

import { defineCustomElements } from '@revolist/revogrid/loader';
defineCustomElements();

import {
  defineGanttToolbar,
  GanttPlugin,
} from '@revolist/revogrid-enterprise';
import { currentTheme } from '../composables/useRandomData';
import './gantt-task-editor-form.css';
import {
  SHOWCASE_ASSIGNMENTS,
  SHOWCASE_DEPENDENCIES,
  SHOWCASE_RESOURCES,
  SHOWCASE_TOOLBAR_COLUMNS,
  STANDARD_CALENDAR,
} from './gantt-project-data';
import {
  createInitialTaskSource,
  TASK_EDITOR_COLUMNS,
  TASK_EDITOR_DIALOG_CONFIG,
  TASK_EDITOR_GANTT_CONFIG,
} from './GanttTaskEditorFormShared';

const { isDark } = currentTheme();

type TaskEditorGridElement = HTMLRevoGridElement & Record<string, any>;

function createElement<K extends keyof HTMLElementTagNameMap>(
  tagName: K,
  className?: string,
): HTMLElementTagNameMap[K] {
  const element = document.createElement(tagName);
  if (className) {
    element.className = className;
  }
  return element;
}

export function load(parentSelector: string | Element) {
  const parent = typeof parentSelector === 'string'
    ? document.querySelector(parentSelector)
    : parentSelector;
  if (!parent) {
    return () => {};
  }

  const taskSource = createInitialTaskSource();

  const root = createElement('section', 'gantt-task-editor-demo');
  const toolbar = createElement('div', 'gantt-task-editor-toolbar');
  const grid = document.createElement('revo-grid') as TaskEditorGridElement;

  grid.className = 'gantt-task-editor-grid';
  grid.theme = isDark() ? 'darkCompact' : 'compact';
  grid.hideAttribution = true;
  grid.plugins = [GanttPlugin as any];
  grid.columns = TASK_EDITOR_COLUMNS;
  grid.gantt = TASK_EDITOR_GANTT_CONFIG;
  grid.ganttCalendars = [STANDARD_CALENDAR];
  grid.ganttDependencies = SHOWCASE_DEPENDENCIES;
  grid.ganttResources = SHOWCASE_RESOURCES;
  grid.ganttAssignments = SHOWCASE_ASSIGNMENTS;
  grid.ganttTaskEditorDialog = TASK_EDITOR_DIALOG_CONFIG;

  root.appendChild(toolbar);
  root.appendChild(grid);
  parent.appendChild(root);
  defineGanttToolbar(toolbar, {
    grid,
    columns: SHOWCASE_TOOLBAR_COLUMNS,
    controls: {
      export: false,
      baseline: false,
    },
  });

  grid.source = taskSource;

  return () => {
    root.remove();
  };
}

React tsx

import React, { useEffect, useMemo, useRef } from 'react';
import { RevoGrid } from '@revolist/react-datagrid';
import { defineGanttToolbar, GanttPlugin } from '@revolist/revogrid-enterprise';
import { currentTheme } from '../composables/useRandomData';
import {
  SHOWCASE_ASSIGNMENTS,
  SHOWCASE_DEPENDENCIES,
  SHOWCASE_RESOURCES,
  SHOWCASE_TOOLBAR_COLUMNS,
  STANDARD_CALENDAR,
} from './gantt-project-data';
import {
  createInitialTaskSource,
  TASK_EDITOR_COLUMNS,
  TASK_EDITOR_DIALOG_CONFIG,
  TASK_EDITOR_GANTT_CONFIG,
} from './GanttTaskEditorFormShared';
import './gantt-task-editor-form.css';

const { isDark } = currentTheme();

export default function GanttTaskEditorForm() {
  const gridRef = useRef<HTMLRevoGridElement>(null);
  const toolbarRef = useRef<HTMLDivElement>(null);

  const source = useMemo(() => createInitialTaskSource(), []);
  const plugins = useMemo(() => [GanttPlugin], []);
  const columns = useMemo(() => TASK_EDITOR_COLUMNS, []);
  const gantt = useMemo(() => TASK_EDITOR_GANTT_CONFIG, []);
  const calendars = useMemo(() => [STANDARD_CALENDAR], []);
  const dependencies = useMemo(() => SHOWCASE_DEPENDENCIES, []);
  const resources = useMemo(() => SHOWCASE_RESOURCES, []);
  const assignments = useMemo(() => SHOWCASE_ASSIGNMENTS, []);
  const taskEditorDialog = useMemo(() => TASK_EDITOR_DIALOG_CONFIG, []);

  useEffect(() => {
    const toolbar = toolbarRef.current;
    const grid = gridRef.current;
    if (!toolbar || !grid) {
      return undefined;
    }

    defineGanttToolbar(toolbar, {
      grid,
      columns: SHOWCASE_TOOLBAR_COLUMNS,
      controls: {
        export: false,
        baseline: false,
      },
    });

    return () => {
      toolbar.textContent = '';
    };
  }, []);

  return (
    <section className="gantt-task-editor-demo">
      <div ref={toolbarRef} className="gantt-task-editor-toolbar" />
      <RevoGrid
        ref={gridRef}
        className="gantt-task-editor-grid"
        theme={isDark() ? 'darkCompact' : 'compact'}
        hideAttribution
        plugins={plugins}
        source={source}
        columns={columns}
        gantt={gantt}
        ganttCalendars={calendars}
        ganttDependencies={dependencies}
        ganttResources={resources}
        ganttAssignments={assignments}
        ganttTaskEditorDialog={taskEditorDialog}
      />
    </section>
  );
}

Vue vue

<template>
  <section class="gantt-task-editor-demo">
    <div ref="toolbarRef" class="gantt-task-editor-toolbar"></div>
    <RevoGrid
      ref="gridRef"
      class="gantt-task-editor-grid"
      hide-attribution
      :theme="isDark ? 'darkCompact' : 'compact'"
      :plugins="plugins"
      :source="tasks"
      :columns="columns"
      :gantt.prop="ganttConfig"
      :gantt-calendars.prop="calendars"
      :gantt-dependencies.prop="dependencies"
      :gantt-resources.prop="resources"
      :gantt-assignments.prop="assignments"
      :gantt-task-editor-dialog.prop="taskEditorDialog"
    />
  </section>
</template>

<script setup lang="ts">
import { nextTick, onBeforeUnmount, onMounted, ref } from 'vue';
import RevoGrid from '@revolist/vue3-datagrid';
import { defineGanttToolbar, GanttPlugin } from '@revolist/revogrid-enterprise';
import { currentThemeVue } from '../composables/useRandomData';
import {
  SHOWCASE_ASSIGNMENTS,
  SHOWCASE_DEPENDENCIES,
  SHOWCASE_RESOURCES,
  SHOWCASE_TOOLBAR_COLUMNS,
  STANDARD_CALENDAR,
} from './gantt-project-data';
import {
  createInitialTaskSource,
  TASK_EDITOR_COLUMNS,
  TASK_EDITOR_DIALOG_CONFIG,
  TASK_EDITOR_GANTT_CONFIG,
} from './GanttTaskEditorFormShared';
import './gantt-task-editor-form.css';

const { isDark } = currentThemeVue();

const plugins = ref([GanttPlugin]);
const columns = ref(TASK_EDITOR_COLUMNS);
const tasks = ref(createInitialTaskSource());
const ganttConfig = ref(TASK_EDITOR_GANTT_CONFIG);
const calendars = ref([STANDARD_CALENDAR]);
const dependencies = ref(SHOWCASE_DEPENDENCIES);
const resources = ref(SHOWCASE_RESOURCES);
const assignments = ref(SHOWCASE_ASSIGNMENTS);
const taskEditorDialog = ref(TASK_EDITOR_DIALOG_CONFIG);

const gridRef = ref<InstanceType<typeof RevoGrid> | HTMLRevoGridElement | null>(null);
const toolbarRef = ref<HTMLElement | null>(null);
let toolbarMounted = false;
let toolbarFrame = 0;

function getGridEl(): HTMLRevoGridElement | null {
  const refValue = gridRef.value as (InstanceType<typeof RevoGrid> & { $el?: HTMLRevoGridElement }) | HTMLRevoGridElement | null;
  const candidate = (refValue && '$el' in refValue ? refValue.$el : refValue) ?? null;
  return candidate instanceof HTMLElement && candidate.tagName.toLowerCase() === 'revo-grid'
    ? candidate as HTMLRevoGridElement
    : null;
}

function mountToolbar() {
  if (toolbarMounted) {
    return;
  }

  const grid = getGridEl();
  if (!toolbarRef.value || !grid) {
    toolbarFrame = requestAnimationFrame(mountToolbar);
    return;
  }

  toolbarMounted = true;
  defineGanttToolbar(toolbarRef.value, {
    grid,
    columns: SHOWCASE_TOOLBAR_COLUMNS,
    controls: {
      export: false,
      baseline: false,
    },
  });
}

onMounted(async () => {
  await nextTick();
  mountToolbar();
});

onBeforeUnmount(() => {
  if (toolbarFrame) {
    cancelAnimationFrame(toolbarFrame);
  }
  if (toolbarRef.value) {
    toolbarRef.value.textContent = '';
  }
});
</script>

Angular ts

import { AfterViewInit, Component, ElementRef, NO_ERRORS_SCHEMA, ViewChild, ViewEncapsulation } from '@angular/core';
import { RevoGrid } from '@revolist/angular-datagrid';
import { defineGanttToolbar, GanttPlugin } from '@revolist/revogrid-enterprise';
import { currentTheme } from '../composables/useRandomData';
import {
  SHOWCASE_ASSIGNMENTS,
  SHOWCASE_DEPENDENCIES,
  SHOWCASE_RESOURCES,
  SHOWCASE_TOOLBAR_COLUMNS,
  STANDARD_CALENDAR,
} from './gantt-project-data';
import {
  createInitialTaskSource,
  TASK_EDITOR_COLUMNS,
  TASK_EDITOR_DIALOG_CONFIG,
  TASK_EDITOR_GANTT_CONFIG,
} from './GanttTaskEditorFormShared';

@Component({
  selector: 'gantt-task-editor-form-grid',
  standalone: true,
  // Allows Angular demos to bind RevoGrid plugin props that are not wrapper inputs.
  schemas: [NO_ERRORS_SCHEMA],
  imports: [RevoGrid],
  template: `
    <section class="gantt-task-editor-demo">
      <div #toolbar class="gantt-task-editor-toolbar"></div>
      <revo-grid
        #grid
        class="gantt-task-editor-grid"
        [theme]="theme"
        [hideAttribution]="true"
        [plugins]="plugins"
        [source]="tasks"
        [columns]="columns"
        [gantt]="ganttConfig"
        [ganttCalendars]="calendars"
        [ganttDependencies]="dependencies"
        [ganttResources]="resources"
        [ganttAssignments]="assignments"
        [ganttTaskEditorDialog]="taskEditorDialog"
      ></revo-grid>
    </section>
  `,
  styleUrls: ['./gantt-task-editor-form.css'],
  encapsulation: ViewEncapsulation.None,
})
export class GanttTaskEditorFormGridComponent implements AfterViewInit {
  @ViewChild('grid', { read: ElementRef }) gridRef!: ElementRef<HTMLRevoGridElement>;
  @ViewChild('toolbar', { read: ElementRef }) toolbarRef!: ElementRef<HTMLElement>;

  theme = currentTheme().isDark() ? 'darkCompact' : 'compact';
  plugins = [GanttPlugin];
  columns = TASK_EDITOR_COLUMNS;
  tasks = createInitialTaskSource();
  ganttConfig = TASK_EDITOR_GANTT_CONFIG;
  calendars = [STANDARD_CALENDAR];
  dependencies = SHOWCASE_DEPENDENCIES;
  resources = SHOWCASE_RESOURCES;
  assignments = SHOWCASE_ASSIGNMENTS;
  taskEditorDialog = TASK_EDITOR_DIALOG_CONFIG;

  ngAfterViewInit(): void {
    defineGanttToolbar(this.toolbarRef.nativeElement, {
      grid: this.gridRef.nativeElement,
      columns: SHOWCASE_TOOLBAR_COLUMNS,
      controls: {
        export: false,
        baseline: false,
      },
    });
  }
}

Project Data ts

/**
 * Shared project data for all Gantt documentation examples.
 *
 * This file is kept as the public import surface for existing demos. The
 * actual constants are grouped by responsibility in the adjacent modules.
 */
export * from './gantt-project-base-data';
export * from './gantt-showcase-data';
export * from './gantt-showcase-columns';

Note

Guide pages explain behavior. For raw type signatures, use Gantt API.

This document crossmatches the desired Scheduler, Gantt, and shared planning-platform feature list against the current implementation in packages/enterprise/plugins/gantt.

Status:

• Existing ✅ - implemented now.
• Partial ☑️ - foundation exists, but product/API/UX work is still needed.
• Planned 🚧 - roadmap item.

Gantt

Project planning with task hierarchy, dependencies, milestones, baselines, calendars, resources, and scheduling logic.

Feature group	Feature	Status	Notes
Task model	Task tree / work breakdown structure	✅	Tasks use parentId and wbsCode.
Task model	Summary tasks	✅	Summary task type and parent rollups exist.
Task model	Regular tasks	✅	Standard task type exists.
Task model	Milestones	✅	Milestone task type exists.
Task model	Collapsible task groups	✅	Tree plugin integration exists.
Task model	Parent-child rollups	✅	Schedule and cost rollups exist.
Dependencies	Finish-to-Start	✅	Supported dependency type.
Dependencies	Start-to-Start	✅	Supported dependency type.
Dependencies	Finish-to-Finish	✅	Supported dependency type.
Dependencies	Start-to-Finish	✅	Supported dependency type.
Dependencies	Lead and lag time	✅	Positive lag and negative lead are supported.
Dependencies	Dependency validation	✅	Validation and diagnostics exist.
Dependencies	Move task dependencies	✅	Dependency drag/link editing exists.
Dependencies	Hide dependency arrows	✅	gantt.visuals.showDependencies = false hides dependency overlays without mutating ganttDependencies.
Scheduling	Auto-scheduling	✅	Dependency-aware recalculation exists.
Scheduling	Manual scheduling	✅	Manual tasks preserve authored dates and can warn.
Scheduling	Forward scheduling	✅	Project-start scheduling exists.
Scheduling	Backward scheduling	✅	Project-finish scheduling exists.
Scheduling	Task constraints	✅	Start/finish no-earlier/no-later and must-start/must-finish constraints exist.
Scheduling	Deadline markers	✅	Deadline fields and indicators exist.
Scheduling	Duration calculation	✅	Calendar-aware duration logic exists.
Scheduling	Start / finish date calculation	✅	Engine computes effective dates.
Scheduling	Task splitting	✅	Split ranges affect date math and rendering.
Critical path	Critical path	✅	Critical path calculation and highlighting exist.
Critical path	Total slack	✅	totalSlackDays is projected.
Critical path	Free slack	🚧	Separate free-slack field is not implemented.
Baselines	Baselines	✅	Baseline snapshots and baseline bars exist.
Baselines	Baseline variance	✅	Start, finish, duration, and progress variance fields exist.
Progress	Percent complete	✅	Progress field and editing exist.
Progress	Progress tracking	✅	Actual dates, remaining duration, and progress-aware scheduling exist.
Calendars	Project calendar	✅	Primary project calendar exists.
Calendars	Task calendar	✅	Tasks reference calendars.
Calendars	Resource calendar	✅	Resources reference calendars.
Calendars	Working / non-working days	✅	Calendar working weekdays exist.
Calendars	Holidays	✅	Calendar holidays exist.
Resources	Resource assignment	✅	Assignment model exists.
Resources	Resource workload view	✅	Resource planning mode exists.
Resources	Resource utilization	✅	Load summaries and capacity display exist.
Resources	Over-allocation warnings	✅	Resource allocation diagnostics exist.
Cost	Cost fields	✅	Explicit and calculated costs exist.
Customization	Custom task fields	☑️	Rows can carry custom data; formal custom field schema is planned.
Customization	Custom columns	☑️	RevoGrid column foundation and packaged Gantt column presets exist; broader custom-column API is planned.
Editing	Inline grid editing	✅	Grid edits patch task fields.
Editing	Drag task bars	✅	Task bar drag exists.
Editing	Resize task bars	✅	Task bar resize exists.
Editing	Progress drag/edit	✅	Progress interaction exists.
Timeline	Zoom levels	✅	Preset and custom zoom exist.
Timeline	Timeline markers	✅	Time ranges, project line, today line, milestone lines, and task markers exist.
Timeline	Today line	✅	Today line is supported.
Selection	Multi-selection	☑️	RevoGrid selection exists; multi-task Gantt operations are planned.
Keyboard	Keyboard navigation	☑️	RevoGrid foundation exists; Gantt-specific shortcuts are planned.
History	Undo / redo	✅	Gantt history snapshots exist.
Import/export	Grid import / export	✅	CSV export is available in RevoGrid core; Excel import/export is available in RevoGrid Pro, with Gantt toolbar action helpers.
Import/export	Gantt project import / export	✅	Typed project snapshots include clone/export/parse JSON helpers, REST/GraphQL adapter examples, and a PostgreSQL persistence recipe; broader project-file adapters are planned.
Import/export	MS Project-style compatibility layer	🚧	🚧.
Performance	Large project virtualization	☑️	RevoGrid virtualization exists; Gantt-specific server/window model is planned.
Performance	Server-side loading for enterprise datasets	🚧	Not implemented.

Scheduler

Resource planning for teams, equipment, rooms, vehicles, and operations.

Feature group	Feature	Status	Notes
Timeline views	Resource timeline view	✅	Resource planning mode renders resource rows with load bars.
Timeline views	Hour / day / week / month / custom range views	✅	Default timeline zoom levels include hour-day, day-week, week-month, month-quarter, quarter-year, year-quarter, and multi-year-quarter; minute-level presets remain advanced/explicit, and custom zoom levels are configurable.
Timeline views	Horizontal scheduling mode	✅	Current resource planning and Gantt timeline are horizontal.
Timeline views	Vertical scheduling mode	🚧	Needs dedicated Scheduler layout.
Resource management	Resource scheduling	☑️	Resources, assignments, capacity, and calendars exist; dedicated events/bookings/jobs model is planned.
Resource management	Multi-resource assignment	✅	Multiple resources can be assigned to a task.
Resource management	Resource grouping	🚧	Resource filtering exists, but grouping UI/API is planned.
Resource management	Nested resource trees	🚧	Needs resource hierarchy model/projection.
Event editing	Drag-and-drop event creation	☑️	Task drag-create exists; Scheduler event creation is planned.
Event editing	Drag-and-drop event moving	☑️	Task bar moving exists; Scheduler event moving is planned.
Event editing	Event resizing	☑️	Task resizing exists; Scheduler event resizing is planned.
Event editing	Event splitting	☑️	Task split ranges exist; Scheduler event split UX is planned.
Event editing	Event merging	🚧	Not implemented.
Event layout	Overlapping event layout	🚧	Needs Scheduler event layout engine.
Event layout	Stack / pack / overlap display modes	🚧	Needs configurable event display modes.
Editing modes	Read-only mode	✅	gantt.readOnly blocks packaged task, dependency, and assignment mutation services.
Editing modes	Editable mode	☑️	Task editing exists; Scheduler event editing is planned.
Calendars	Custom working hours	☑️	Calendars support working days, holidays, hours/day, and intraday working-hour ranges through inline gantt.calendars or ganttCalendars for hour-mode Gantt shading/snapping.
Calendars	Non-working time highlighting	✅	Timeline can shade non-working time.
Calendars	Timezone support	✅	Project and calendars carry IANA time zones.
Recurrence	Recurring events	🚧	Not implemented.
Recurrence	Event exceptions	🚧	Not implemented.
Validation	Event validation hooks	☑️	Cancelable before-change hooks exist for tasks, dependencies, and assignments. Event-specific hooks are planned.
Validation	Conflict detection	☑️	Resource over-allocation and scheduling diagnostics exist; booking conflict rules are planned.
Validation	Capacity warnings	✅	Resource planning supports capacity and over-allocation display.
Validation	Availability rules	☑️	Resource calendars exist; richer availability rules are planned.
Validation	Locked events	☑️	Gantt tasks support locked; Scheduler event locks remain planned.
Rendering	Custom event templates	☑️	Task renderer hooks exist; Scheduler event renderer API is planned.
Rendering	Custom resource rows	☑️	Resource row projection exists; public custom resource row API is planned.
Rendering	Custom timeline headers	✅	Timeline zoom/header configuration exists.
Rendering	Tooltips and popovers	☑️	Task tooltip hook and Gantt task detail popover model exist; richer Scheduler popovers are planned.
Grid UX	Inline editing	✅	Grid edits update task data.
Grid UX	Keyboard navigation	☑️	RevoGrid foundation exists; Scheduler-specific keyboard workflows are planned.
Grid UX	Copy / paste	☑️	RevoGrid foundation exists; Scheduler-specific behavior is planned.
Grid UX	Undo / redo	✅	Gantt integrates with history snapshots.
Grid UX	Filtering and search	✅	Tree-aware Gantt search exists.
Grid UX	Typed task-column filters	✅	Built-in numeric task columns use number filters, and built-in date task columns use the date filter family while preserving explicit column overrides.
Performance	Virtual scrolling for large datasets	☑️	RevoGrid virtualization exists; Scheduler-specific data windowing is planned.
Performance	Lazy loading by date range	🚧	Not implemented.
Export	Excel export	✅	Supported through RevoGrid Pro ExportExcelPlugin for grid data. Timeline-image/workbook specialization can be added later.
Export	Excel import	✅	Supported through RevoGrid Pro ExportExcelPlugin; Gantt-specific project mapping can be added later.
Export	CSV export	✅	Supported through RevoGrid core ExportFilePlugin when grid exporting is enabled.
Export	PDF export	☑️	Print-oriented reporting recipe exists; timeline/PDF layout export is not provided by the current grid export plugins. A combined PDF + Excel reporting recipe documents the recommended toolbar wiring.

Shared RevoGrid Planning Platform

Built on the same high-performance grid engine and scheduling foundation.

Feature group	Feature	Status	Notes
Data model	Tasks	✅	TaskEntity.
Data model	Events	🚧	Scheduler event entity is planned.
Data model	Resources	✅	ResourceEntity.
Data model	Assignments	✅	AssignmentEntity.
Data model	Dependencies	✅	DependencyEntity.
Data model	Calendars	✅	CalendarEntity.
Data model	Baselines	✅	BaselineSnapshot.
Data model	Time ranges	✅	Timeline visual ranges exist.
Data model	Constraints	✅	Task constraints exist.
Data model	Custom metadata	☑️	Tags/notes and row extensibility exist; typed metadata schema is planned.
Data model	Custom field schemas	🚧	Not implemented.
Data model	Typed data models	✅	Typed config, entities, events, and projected rows exist.
Data model	Framework-agnostic core	✅	Engine/projection/core are framework-independent TypeScript modules.
Scheduling engine	Calendar-aware date calculation	✅	Implemented.
Scheduling engine	Dependency-aware recalculation	✅	Implemented.
Scheduling engine	Forward scheduling	✅	Implemented.
Scheduling engine	Backward scheduling	✅	Implemented.
Scheduling engine	Manual vs automatic scheduling	✅	Implemented.
Scheduling engine	Constraint handling	✅	Implemented.
Scheduling engine	Critical path calculation	✅	Implemented.
Scheduling engine	Resource conflict detection	✅	Implemented as resource over-allocation diagnostics.
Scheduling engine	Configurable validation rules	☑️	Policy options and cancelable hooks exist; rule registry is planned.
Scheduling engine	Transaction-based updates	☑️	Mutation services exist; public transaction API is planned.
Scheduling engine	Batch recalculation	✅	Engine recalculates resolved project snapshots.
Scheduling engine	Deterministic scheduling results	✅	Implemented.
Grid foundation	RevoGrid-powered left-side grid	✅	Gantt projects rows and columns into RevoGrid.
Grid foundation	Virtualized rows and columns	✅	RevoGrid foundation.
Grid foundation	Frozen columns	✅	RevoGrid/Pro foundation.
Grid foundation	Column grouping	✅	RevoGrid foundation.
Grid foundation	Column resizing	✅	RevoGrid foundation.
Grid foundation	Column reordering	✅	RevoGrid foundation.
Grid foundation	Custom cell renderers	✅	RevoGrid templates and Gantt bar hooks.
Grid foundation	Custom editors	☑️	RevoGrid editor foundation exists; Gantt editor forms are planned.
Grid foundation	Tree data	✅	Tree plugin integration.
Grid foundation	Row grouping	☑️	RevoGrid/Pro foundation exists; Gantt-specific row grouping is planned.
Grid foundation	Sorting	☑️	RevoGrid foundation exists; scheduler-safe sorting policy is planned.
Grid foundation	Filtering	✅	Gantt search and RevoGrid filtering foundation.
Grid foundation	Selection	✅	RevoGrid foundation.
Grid foundation	Clipboard	✅	RevoGrid/Pro foundation.
Grid foundation	Keyboard navigation	✅	RevoGrid foundation.
Grid foundation	Theming	✅	Gantt SCSS and RevoGrid theming foundation.
Grid foundation	Plugin architecture	✅	Gantt composes feature tools and Pro plugins.
Enterprise performance	Virtual rendering	✅	RevoGrid foundation.
Enterprise performance	Large dataset support	☑️	Rendering foundation exists; server/window data model is planned.
Enterprise performance	Lazy loading	🚧	Not implemented.
Enterprise performance	Date-range loading	🚧	Not implemented.
Enterprise performance	Viewport-aware loading	🚧	Not implemented.
Enterprise performance	Server-side data model	🚧	Not implemented.
Enterprise performance	Incremental updates	☑️	Local mutation services exist; remote incremental sync is planned.
Enterprise performance	Real-time updates	🚧	Not implemented.
Enterprise performance	Optimistic updates	🚧	Not implemented.
Enterprise performance	WebSocket-ready data flow	🚧	Not implemented.
Enterprise performance	Batched mutations	☑️	Controlled local mutations exist; explicit batch API is planned.
Enterprise performance	Minimal re-rendering	☑️	Grid sync update modes exist.
Framework support	React	✅	Gantt demos/components exist.
Framework support	Vue	✅	Gantt demos/components exist.
Framework support	Angular	✅	Gantt demos/components exist.
Framework support	Svelte	☑️	Svelte usage example exists; packaged wrapper/API docs are planned.
Extensibility	Custom task renderer	✅	Task bar color/content/tooltip hooks.
Extensibility	Custom event renderer	🚧	Requires Scheduler event model.
Extensibility	Custom dependency renderer	☑️	Dependency layer exists; public renderer hook is planned.
Extensibility	Custom tooltip renderer	✅	Task tooltip hook and built-in tooltip field selection exist.
Extensibility	Custom editor forms	✅	Task editor form schema, submit normalization helper, and packaged Preact row-context-menu dialog plugin exist; the packaged dialog edits task fields and resource assignments.
Extensibility	Custom validation	☑️	Cancelable before-change events and validation recipe examples exist; validation registry is planned.
Extensibility	Custom scheduling rules	🚧	🚧.
Extensibility	Custom calendars	✅	Calendar entities are configurable.
Extensibility	Custom export pipeline	☑️	Gantt Excel row mapping, toolbar export actions, print recipe, and combined PDF + Excel reporting recipe exist; full pipeline hooks are planned.
Extensibility	Custom context menu	✅	Gantt enables row, column, and timeline context menus by default, prepends default actions through RevoGrid Pro ContextMenuPlugin, preserves custom menu items, and supports opt-out through gantt.contextMenu.
Extensibility	Plugin API	✅	Gantt plugin and feature-tool architecture exist.
Extensibility	Event lifecycle hooks	✅	Before-change and interaction events exist.
Extensibility	Typed API	✅	Typed config/entities/events exist.
Collaboration	Optimistic editing	🚧	🚧.
Collaboration	Conflict resolution hooks	🚧	🚧.
Collaboration	Change history	✅	History integration exists.
Collaboration	Audit log support	🚧	🚧.
Collaboration	User presence markers	🚧	🚧.
Collaboration	Comments on tasks/events	🚧	🚧.
Collaboration	Locking / checkout mode	☑️	Gantt task locked prevents packaged task mutation paths; broader checkout workflows are planned.
Collaboration	Role-based editability	☑️	Role/permission helpers exist for before-change hooks; packaged policy wiring is planned.
Collaboration	Read-only views	✅	gantt.readOnly blocks packaged task, dependency, and assignment mutations.
Collaboration	Approval workflow hooks	🚧	🚧.
Export and integration	CSV export	✅	RevoGrid core ExportFilePlugin exports visible grid data as CSV.
Export and integration	Excel export	✅	RevoGrid Pro ExportExcelPlugin exports grid data to .xlsx.
Export and integration	Excel import	✅	RevoGrid Pro ExportExcelPlugin imports .xlsx/.xls into the grid.
Export and integration	PDF export	☑️	Print-oriented reporting recipe exists; native PDF export is not implemented by core/Pro/Gantt export plugins.
Export and integration	PNG export	🚧	Not implemented by core/Pro/Gantt export plugins.
Export and integration	JSON import/export	✅	Gantt core exports clone/export/parse helpers for typed project snapshots.
Export and integration	iCalendar support for Scheduler	🚧	🚧.
Export and integration	MS Project-style import/export layer	🚧	🚧.
Export and integration	REST API integration	☑️	Project snapshot REST adapter example exists; production backend templates are planned.
Export and integration	GraphQL integration	☑️	Project snapshot GraphQL adapter example exists; production backend templates are planned.
Export and integration	Server-side adapter examples	☑️	REST, GraphQL, and PostgreSQL/Supabase-style examples exist; Firebase and server-window examples are planned.
Export and integration	Supabase / Firebase / PostgreSQL examples	☑️	PostgreSQL SQL builders and Supabase-style adapter exist; Firebase example is planned.
Export and integration	Headless scheduling engine mode	☑️	Engine is framework-independent; public headless API/package is planned.

Feature: Gantt Task Editor Dialog Plugin

Status: Existing ✅

The packaged task editor dialog provides an MS Project-style “Task Information” entry point without forcing application teams to build the popup UI from scratch. GanttPlugin installs GanttTaskEditorDialogPlugin by default for every Gantt instance; the plugin mounts a Preact <dialog> host beside the grid, prepends Edit... to the row context menu, renders the task editor schema from TASK_EDITOR_FIELD_SCHEMA, and normalizes submissions with normalizeTaskEditorSubmit().

Design notes:

• The plugin is still exported as a separate enterprise plugin for backwards compatibility, but GanttPlugin auto-installs it so teams do not need to register it manually for normal Gantt usage.
• Row context menus get Edit... from the task editor plugin and Add from the Gantt context-menu tool by default; both compose with custom row context-menu configuration instead of replacing application items.
• gantt.contextMenu = false opts out of generated Gantt menu items; ganttTaskEditorDialog.contextMenu can independently disable or re-enable the packaged edit-task menu entry.
• Double-clicking a Gantt task, milestone, or summary bar dispatches gantt-task-edit, which opens the packaged editor when GanttTaskEditorDialogPlugin is installed.
• Newly created tasks open in the editor by default after gantt-task-created; ganttTaskEditorDialog.openOnCreate = false keeps creation silent for applications that want a custom follow-up flow.
• The dialog is closed by default. Its CSS explicitly hides dialog:not([open]) so the browser default dialog box never occupies layout before a user opens it.
• Default submit behavior applies task field patches through the Gantt runtime/provider edit path, not by replacing grid.source directly. Applications can intercept through ganttTaskEditorDialog.onSubmit; returning false skips the default update.
• History covers task editor task field patches, resource assignment changes, dependency tab changes, direct external grid.source edits observed by Gantt, and toolbar-driven task/dependency/baseline changes.
• Task resolution prefers Gantt task-bar data-gantt-task-id, then focused row data, then row text fallback for framework/browser context-menu timing differences.
• Read-only projects hide the context-menu item unless ganttTaskEditorDialog.readOnly overrides the behavior.

Current Extra Strengths Beyond The Initial List

Area	Feature	Status
Scheduling	Backward/project-finish scheduling	✅
Scheduling	Resource leveling modes: off, warn, auto	✅
Scheduling	Slack-bound resource leveling	✅
Scheduling	Progress-aware remaining-duration scheduling	✅
Scheduling	Fixed-duration, fixed-work, and fixed-units effort modes	✅
Diagnostics	Scheduler warnings projected into row data	✅
Diagnostics	Dependency validation summary helper	✅
Diagnostics	Resource over-allocation summary helper	✅
Dependencies	Predecessor/successor text parser and formatter	✅
Timeline	Custom milestone flag lines	✅
Timeline	Custom task marker hook	✅
Timeline	Custom task bar color/content/tooltip hooks	✅
Toolbar	Baseline capture, critical-path toggle, and timeline navigation actions	✅
Rendering	Read-only and locked-task indicator metadata	✅
Cost	Assignment-derived cost and parent cost rollups	✅
History	Structural undo/redo for task hierarchy and dependencies	✅
Search	Tree-aware search preserving ancestors and descendants	✅

Roadmap Summary

Priority area	🚧 work
Scheduler product layer	Event model, booking/job/shift terminology, dedicated views, recurrence, exceptions, vertical mode, event layout modes, Scheduler-specific renderers and validation.
Enterprise data	Lazy loading, date-range loading, viewport-aware loading, server-side model, real-time adapters, optimistic updates, WebSocket-ready data flow.
Collaboration	Presence, comments, audit logs, role-based editability, locking/check-out, conflict resolution, approval hooks.
Import/export	Native PDF/PNG export, iCalendar, MS Project-style compatibility layer. CSV export and Excel import/export already come from RevoGrid core/Pro; Gantt adds toolbar helpers, Excel row mapping, print recipe, and JSON project snapshot helpers.
Extensibility	Custom dependency renderer, editor forms, scheduling-rule registry, export pipeline.
Integrations	Firebase, production server-side templates, headless scheduling engine API/package, packaged Svelte docs/wrapper. REST, GraphQL, and PostgreSQL/Supabase-style examples now exist.