{"id":16061,"date":"2026-10-30T10:10:00","date_gmt":"2026-10-30T07:10:00","guid":{"rendered":"https:\/\/dhtmlx.com\/blog\/?p=16061"},"modified":"2026-10-30T12:47:23","modified_gmt":"2026-10-30T09:47:23","slug":"dhtmlx-planning-engine-1-0","status":"publish","type":"post","link":"https:\/\/dhtmlx.com\/blog\/dhtmlx-planning-engine-1-0\/","title":{"rendered":"DHTMLX Planning Engine 1.0: Scheduling, Leveling, and Staffing in One Headless Library"},"content":{"rendered":"<p>A Gantt chart gives teams a clear view of workflows along the timeline and helps identify bottlenecks as a project progresses. When tasks lag behind the schedule, resources become overloaded, or priorities change, it is necessary to adjust the plan, and that process is not always automated.<\/p>\n<p>Today, we are happy to announce a brand-new <a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/\" target=\"_blank\">DHTMLX Planning Engine<\/a> designed to help your application handle situations when things don\u2019t go as planned: recalculate the schedule, balance resource workloads, evaluate alternatives, and suggest suitable task assignments.<\/p>\n<p>Curious how it all works? Let\u2019s take a closer look at the new DHTMLX product.<\/p>\n<h2>Intelligent Planning Level-Up for Your Application<\/h2>\n<p>DHTMLX Planning Engine is a headless library that extends an application\u2019s functionality with an advanced planning calculation core. Its key objective is to address two essential aspects of project planning: delivering a realistic schedule for project tasks and resolving resource overloads where possible. <\/p>\n<p>These planning challenges emerge in many types of business applications. Construction management software should account for crew availability and shift calendars, manufacturing solutions must handle work-order sequencing, and consulting platforms require proper staff utilization mechanisms.<\/p>\n<p>Complex workflows involving thousands of tasks, combined with persistent resource allocation issues, compel organizations to look for new ways to improve their planning. At the same time, adding new planning capabilities to existing enterprise software often creates significant development and maintenance overhead. That\u2019s where DHTMLX Planning Engine can prove valuable with features such as:<\/p>\n<ul>\n<li>high-performance project scheduling,<\/li>\n<li>intelligent resource leveling,<\/li>\n<li>what-if scenario calculations,<\/li>\n<li>assignment suggestions,<\/li>\n<li>plan diagnostics.<\/li>\n<\/ul>\n<p> And all that can be smoothly incorporated into enterprise applications based on any stack without adding unnecessary architectural complexity. <\/p>\n<p><iframe loading=\"lazy\" width=\"100%\" height=\"455\" src=\"https:\/\/www.youtube.com\/embed\/j6URXOHVxEg\" title=\"YouTube video player\" frameborder=\"0\" allow=\"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" allowfullscreen><\/iframe><\/p>\n<h3>Key Engine\u2019s Planning Capabilities in Focus<\/h3>\n<p>Now, it is time to learn how DHTMLX Planning Engine turns planning rules and resource constraints into a feasible project schedule with actionable alternatives. Here are the key capabilities that make up this process:<\/p>\n<h3>1. Calculating the schedule<\/h3>\n<p>Using project data from the host application, the engine calculates the schedule taking into account all specified rules. The engine can execute forward and backward scheduling, placing work at its earliest and latest permitted dates, respectively. The resulting plan can be valid, but it alone doesn\u2019t guarantee that the project team will cope with every task as planned. For instance, two tasks may be scheduled to start simultaneously because their dependencies do not prohibit them from overlapping, but if both tasks need the same resource at full capacity, the resource becomes overloaded, as shown in the example below.<\/p>\n<p><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image2-10.png\" alt=\"resource overload\" width=\"1372\" height=\"719\" class=\"alignleft size-full wp-image-16062\" srcset=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image2-10.png 1372w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image2-10-300x157.png 300w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image2-10-1024x537.png 1024w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image2-10-768x402.png 768w\" sizes=\"auto, (max-width: 1372px) 100vw, 1372px\" \/><br \/>\n<a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/demos\/level-resources\/\" target=\"_blank\">Check the sample ><\/a> <\/p>\n<h3>2. Leveling the workload<\/h3>\n<p>When you assign more tasks to resources than they can handle, the key feature of DHTMLX Planning Engine comes into play: resource leveling. The engine uses it to adjust the schedule by delaying tasks or pausing or resuming them until all project resources are loaded with work within their capacity.<br \/>\n<img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image1-6.png\" alt=\"resource workload capacity calendar\" width=\"1434\" height=\"462\" class=\"alignleft size-full wp-image-16063\" srcset=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image1-6.png 1434w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image1-6-300x97.png 300w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image1-6-1024x330.png 1024w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image1-6-768x247.png 768w\" sizes=\"auto, (max-width: 1434px) 100vw, 1434px\" \/><br \/>\n<a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/demos\/resource-load\/\" target=\"_blank\">Check the sample ><\/a><br \/>\nIf needed, it is possible to limit the impact of leveling to particular resources, a few tasks, or a date range. If an overload cannot be leveled, for instance because of constraints, the engine reports on the causes.<\/p>\n<h3>3. Previewing alternative (what-if) scenarios<\/h3>\n<p>Every plan comes with its own \u201cwhat-if\u201d questions. What if a task starts later than expected? What if a deadline moves or a resource becomes unavailable? DHTMLX Planning Engine helps estimate such scenarios. It calculates the consequences of hypothetical changes on a separate copy of the plan. The original plan remains unchanged during the preview, and the application can apply the proposed scenario only when the user agrees to it. <\/p>\n<p>If the plan changes when a user weighs a suggested scenario, its results may become invalid. The engine provides baseline checks, which help ensure that the application won\u2019t apply a proposal based on outdated information. <\/p>\n<h3>4. Choosing the best available resource for a task<\/h3>\n<p>Assigning a task involves more than simply checking which resources are currently available. An insufficiently considered assignment may fill in a gap in one part of the project, but create scheduling conflicts elsewhere. DHTMLX Planning Engine offers a more thorough approach to this question. The user only needs to select potential assignees for a task. The engine estimates each resource by recalculating and leveling the schedule. Then, it creates a scoreboard for each candidate, where they are ranked by how far the project finish moves, how much overload is left, and which commitments break. These are default ranking criteria used by the engine, but it is also possible to apply your own selection rules.<br \/>\n<img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image4-4.png\" alt=\"choosing the most suitable resource for a task\" width=\"1370\" height=\"804\" class=\"alignleft size-full wp-image-16064\" srcset=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image4-4.png 1370w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image4-4-300x176.png 300w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image4-4-1024x601.png 1024w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image4-4-768x451.png 768w\" sizes=\"auto, (max-width: 1370px) 100vw, 1370px\" \/><br \/>\n<a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/demos\/assign-and-compare\/\" target=\"_blank\">Check the sample ><\/a><br \/>\nEach suggested assignee is evaluated on a separate copy of the plan, so the user can compare alternatives before the user chooses the most suitable option. <\/p>\n<h3>5. Staffing by skill<\/h3>\n<p>If choosing the right person for a task is tricky, staffing an entire sprint can be much harder. DHTMLX Planning Engine can help with this, too. The user just presents the quantity of resources and skills required for each task, and the engine takes care of the rest. The engine builds a staffing plan by matching team members\u2019 skills to task requirements.<br \/>\n<img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/ezgif-effects.gif\" alt=\"staffing by skill\" width=\"1902\" height=\"894\" class=\"alignleft size-full wp-image-16065\" \/><br \/>\n<a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/demos\/skills-assign\/\" target=\"_blank\">Check the sample ><\/a><\/p>\n<p>The engine also explains its recommendations on each assignment. If it cannot staff a task with the required resources, it clarifies whether the issue is a lack of required skills or availability.<\/p>\n<p>Together, these capabilities form the core of the engine\u2019s planning workflow. But their practical value also depends on how fast the engine can operate in various scenarios.<\/p>\n<h3>Scaling Up Planning Performance<\/h3>\n<p>DHTMLX Planning Engine is built to remain responsive during demanding planning operations across different implementations and workloads. In our benchmarks, DHTMLX Planning Engine recalculated a 10,000-task project after an edit in about 0.7 ms in Rust and 1.1 ms in WebAssembly. Generating edit previews took about 1.3 ms and 1.7 ms, respectively.<\/p>\n<p>These results are a part of a broader benchmark suite covering projects with thousands of tasks, schedule recalculation after edits, resource leveling, and evaluation of alternative assignments. See the <a href=\"https:\/\/docs.dhtmlx.com\/planning-engine\/performance\/\" target=\"_blank\">DHTMLX Planning Engine benchmarks<\/a> to learn more details on results and test conditions.<\/p>\n<p>Beyond what the engine can do, it is also important to understand how easily you can put it to work. <\/p>\n<h2>How DHTMLX Planning Engine Fits into Apps<\/h2>\n<p>Integration complexity is often a major stumbling block for driving innovations into enterprise applications. But it is not the case with the DHTMLX Planning Engine. Right after its extensive planning capabilities, what truly stands out is the engine\u2019s cross-platform nature combined with a flexible, headless architecture.<\/p>\n<p>The engine offers APIs for Rust, TypeScript, .NET, and Java, as well as a WebAssembly module for browser or worker deployment. So, it can run both in the browser and on the server. In the browser, it responds to task edits and prepares previews (what-if scenarios) immediately without round trips to the server. On the server, the engine can validate plans, recalculate projects in the background, or check whether a proposed plan is feasible before saving it. Using the engine in both environments helps avoid mismatches between what users see and what backend processes calculate.<\/p>\n<p>The engine has no built-in UI and keeps no data, so the host application remains in charge of data storage, plan presentation, and workflow decisions. The engine can be smoothly embedded right behind the app\u2019s existing interface and feed its planning results to a Gantt chart, grid table, Kanban board, scheduling calendar, custom views, or work with no UI at all.<\/p>\n<p>There are also two modes for processing planning data. Stateless snapshot mode accepts project data in JSON format and returns only a piece of project data containing updates, along with relevant conflicts, warnings, and planning analytics. In resident engine mode, the engine builds an in-memory schedule model and incrementally recalculates affected tasks after supported edits. It also supports forks for previewing changes and exploring what-if scenarios without modifying the original schedule.<\/p>\n<p>This flexibility makes DHTMLX Planning Engine a welcome addition to a wide range of project planning solutions based on popular technology stacks. One vivid example is its straightforward integration with DHTMLX Gantt. Read on to learn how the two work together.<\/p>\n<h2>Why New Planning Engine is a Perfect Match for DHTMLX Gantt<\/h2>\n<p><a href=\"https:\/\/dhtmlx.com\/docs\/products\/dhtmlxGantt\/\" target=\"_blank\">DHTMLX JavaScript Gantt chart<\/a> already offers a solid foundation for project scheduling and resource management, proven in hundreds of real-world applications. With the new DHTMLX Planning Engine, you can bring these Gantt capabilities to an entirely new level. <\/p>\n<p><img loading=\"lazy\" decoding=\"async\" src=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image5-5.png\" alt=\"DHTMLX Gantt powered by planning engine\" width=\"1314\" height=\"743\" class=\"alignleft size-full wp-image-16067\" srcset=\"https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image5-5.png 1314w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image5-5-300x170.png 300w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image5-5-1024x579.png 1024w, https:\/\/dhtmlx.com\/blog\/wp-content\/uploads\/2026\/10\/image5-5-768x434.png 768w\" sizes=\"auto, (max-width: 1314px) 100vw, 1314px\" \/><a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/demos\/gantt-level-resources\/\" target=\"_blank\">Check the sample > <\/a><\/p>\n<p>To get started, all you need to do is import the package and register the Planning Engine as the new DHTMLX Gantt\u2019s scheduling engine:<\/p>\n<div class=\"codecolorer-container javascript default\" style=\"overflow:auto;white-space:nowrap;\"><div class=\"javascript codecolorer\"><span class=\"kw5\">import<\/span> <span class=\"br0\">&#123;<\/span> PlanningEngine <span class=\"br0\">&#125;<\/span> from <span class=\"st0\">&quot;@dhx\/planning-engine&quot;<\/span><span class=\"sy0\">;<\/span><br \/>\ngantt.<span class=\"me1\">setSchedulingEngine<\/span><span class=\"br0\">&#40;<\/span>PlanningEngine<span class=\"br0\">&#41;<\/span><span class=\"sy0\">;<\/span><\/div><\/div>\n<p>From this point on, the new Planning Engine replaces Gantt\u2019s built-in auto-scheduling functionality, introducing resource leveling and improved scheduling logic. On the same dataset, the new engine schedules ten times faster. It also supports incremental recalculation, updating only the affected parts of a loaded plan.  <\/p>\n<p>Everything else in your application remains the same. Gantt continues to provide the interface for working with project data. <\/p>\n<p>What about data compatibility? It\u2019s quite straightforward. The data model of the Planning Engine uses the same field names as DHTMLX Gantt. Tasks, links, calendars, and resource assignments go in without a conversion step, and the results come back in a format the Gantt already understands. For instance, the following function passes Gantt\u2019s project data to the engine, runs resource leveling, and applies the returned updates to Gantt:<\/p>\n<div class=\"codecolorer-container javascript default\" style=\"overflow:auto;white-space:nowrap;\"><div class=\"javascript codecolorer\"><span class=\"kw1\">function<\/span> levelResources<span class=\"br0\">&#40;<\/span><span class=\"br0\">&#41;<\/span> <span class=\"br0\">&#123;<\/span><br \/>\n&nbsp; &nbsp; <span class=\"kw1\">const<\/span> updates <span class=\"sy0\">=<\/span> engine.<span class=\"me1\">levelResources<\/span><span class=\"br0\">&#40;<\/span>gantt.<span class=\"me1\">getData<\/span><span class=\"br0\">&#40;<\/span><span class=\"br0\">&#41;<\/span><span class=\"br0\">&#41;<\/span><span class=\"sy0\">;<\/span><br \/>\n&nbsp; &nbsp; gantt.<span class=\"me1\">applyUpdates<\/span><span class=\"br0\">&#40;<\/span>updates<span class=\"br0\">&#41;<\/span><span class=\"sy0\">;<\/span><br \/>\n<span class=\"br0\">&#125;<\/span><\/div><\/div>\n<p>Previews (what-if scenarios), candidate scoring, and staffing by skill follow the same principle: provide the engine with relevant data and apply the results it returns in the Gantt chart.  <\/p>\n<p>Learn more on how to make the most of the DHTMLX Planning Engine in combination with the Gantt component in the <a href=\"https:\/\/docs.dhtmlx.com\/planning-engine\/dhx-gantt-parity\/\" target=\"_blank\">documentation<\/a>. <\/p>\n<h2>Getting Started with DHTMLX Planning Engine<\/h2>\n<p>DHTMLX Planning Engine is available under a commercial license. You can request licensing and pricing information or apply for a free 30-day trial version using the following links:<\/p>\n<ul>\n<li><a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/#requestform\" target=\"_blank\">Request licensing and pricing details<\/a><\/li>\n<li><a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/request-trial\/\" target=\"_blank\">Request a free 30-day trial<\/a><\/li>\n<\/ul>\n<p>Working on a new planning solution? Tell us about your scheduling requirements and resource optimization needs. Our team will help you explore how DHTMLX Planning Engine can benefit your project.<\/p>\n<h2>Related Materials<\/h2>\n<ul>\n<li><a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/\" target=\"_blank\">DHTMLX Planning Engine (landing page)<\/a><\/li>\n<li><a href=\"https:\/\/docs.dhtmlx.com\/planning-engine\/\" target=\"_blank\">Documentation<\/a><\/li>\n<li><a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/demos\/\" target=\"_blank\">Demos and examples<\/a><\/li>\n<li><a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/#requestform\" target=\"_blank\">Request licensing and pricing details<\/a><\/li>\n<li><a href=\"https:\/\/dhtmlx.com\/docs\/products\/planning-engine\/request-trial\/\" target=\"_blank\">Request a free 30-day trial<\/a><\/li>\n<\/ul>\n","protected":false},"excerpt":{"rendered":"<p>A Gantt chart gives teams a clear view of workflows along the timeline and helps identify bottlenecks as a project progresses. When tasks lag behind the schedule, resources become &#8230;<\/p>\n","protected":false},"author":101014,"featured_media":16066,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[70,1],"tags":[33,87],"class_list":["post-16061","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-releases","category-uncategorized","tag-all-posts","tag-planning-engine"],"_links":{"self":[{"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/posts\/16061","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/users\/101014"}],"replies":[{"embeddable":true,"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/comments?post=16061"}],"version-history":[{"count":23,"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/posts\/16061\/revisions"}],"predecessor-version":[{"id":16093,"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/posts\/16061\/revisions\/16093"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/media\/16066"}],"wp:attachment":[{"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/media?parent=16061"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/categories?post=16061"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/dhtmlx.com\/blog\/wp-json\/wp\/v2\/tags?post=16061"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}