Critical Path Calculator (CPM)

The critical path is the longest chain of dependent activities in a project schedule, and it sets the shortest possible time in which the whole project can finish. This critical path calculator takes a list of activities, their durations and their predecessors, runs a full forward and backward pass, and returns the early and late dates, the total and free float of every task, the identified critical path, and the project duration. Enter your network above, press calculate, and read the schedule the way a professional scheduler does.

What the Critical Path Method actually calculates

The Critical Path Method (CPM) is a deterministic scheduling technique. You describe a project as a network of activities connected by finish-to-start dependencies: activity C cannot begin until activities A and B are complete. Each activity has a single, known duration. CPM then answers three questions at once. How long will the project take? Which activities cannot slip without delaying the whole project? And how much spare time — float — does every non-critical activity carry?

The answer to the first question is the project duration, the length of the longest path through the network. The answer to the second is the critical path itself: the sequence of activities whose total float is zero. The answer to the third is the float table, which tells a project manager exactly where slack exists and where it does not. Those three outputs are the backbone of every schedule review, resource plan and recovery decision in project management.

CPM works on the activity-on-node convention, where each box is an activity and each arrow is a dependency. The calculator on this page uses that convention. You type one activity per line as ID, duration, predecessors — for example C, 2, A;B means activity C lasts two time units and starts only after both A and B finish. Start activities simply have no predecessors.

The forward pass: early start and early finish

The forward pass sweeps through the network from start to end and computes, for every activity, the earliest it can possibly begin and end. The early start (ES) of an activity is the largest early finish of all its predecessors; activities with no predecessors start at time zero. The early finish (EF) is simply the early start plus the duration:

ES = max(EF of all predecessors)    EF = ES + duration

The reason we take the maximum rather than the minimum is intuitive: an activity that depends on several predecessors must wait for the slowest of them. When the forward pass reaches the final activities, the largest early finish among them is the project duration. That single number is the earliest the project can be delivered given the dependencies and durations you entered.

The backward pass: late start and late finish

The backward pass runs in reverse, from the end of the project back to the start, and computes the latest each activity can finish and start without pushing out the project end date. We set the late finish (LF) of the final activities equal to the project duration, then work backwards. The late finish of any activity is the smallest late start of its successors, and the late start (LS) is the late finish minus the duration:

LF = min(LS of all successors)    LS = LF − duration

Here we take the minimum because an activity must finish in time for the earliest of its successors to keep to its own late schedule. When the forward and backward passes are both complete, every activity carries four dates — ES, EF, LS and LF — and the difference between the late and early dates reveals the float.

Total float and free float

Total float (TF) is the amount of time an activity can be delayed from its early start without delaying the project completion date. It equals the late start minus the early start, which is identical to the late finish minus the early finish:

Total float = LS − ES = LF − EF

Activities with zero total float are critical — any delay to them delays the whole project. The chain of zero-float activities is the critical path. Free float (FF) is stricter: it is the time an activity can be delayed without delaying the early start of any of its immediate successors. It equals the smallest early start of the successors minus the activity’s early finish:

Free float = min(ES of successors) − EF

Free float is always less than or equal to total float. The distinction matters in practice: consuming total float on one activity can eat into the float of activities downstream, whereas consuming only free float leaves every successor’s schedule untouched. Good schedulers watch both columns.

Worked examples

Example 1 — a six-activity network. Suppose a project has activities A (3), B (4), C (2, after A), D (5, after B), E (1, after C and D) and F (2, after E). The forward pass gives A finishing at 3, B at 4, C from 3 to 5, D from 4 to 9, E from 9 to 10 and F from 10 to 12. The project duration is 12 time units.

The backward pass shows that B, D, E and F all have zero float, while A carries four units of total float and C carries four as well. The critical path is therefore B → D → E → F. Notice that the longer parallel branch (B–D, totalling 9) dominates the shorter one (A–C, totalling 5); the four-unit gap is exactly the float on A and C.

Type this network into the calculator with the “Load example” button to see the full table and timeline.

Example 2 — a simple chain. If activities run strictly in series — A (2) then B (3) then C (1) — there is only one path, so every activity is critical and the project duration is the sum, 6 time units. Every activity has zero total and free float because there is no alternative route to absorb delay. Pure chains have no slack anywhere, which is why breaking work into parallel streams is one of the few ways to shorten a schedule without adding resources.

Example 3 — parallel branches that merge. Consider a start milestone S (0), then a long task P (10) and a short task Q (3) both starting after S, merging into a finish milestone T (0). The forward pass makes the project 10 units long, driven entirely by P. Q finishes at 3 but does not need to complete until 10, so it carries 7 units of total float. P is critical; Q is not. This is the canonical pattern behind most real schedules: one dominant branch defines the duration and everything shorter has slack.

How to read the results table

Each row of the output table is one activity. The ES, EF, LS and LF columns give the four scheduling dates. The total float column is the headline number for risk: zero means critical, a positive value means the activity can slip that many units before it threatens the deadline. The free float column tells you how much of that slippage is “safe” in the sense that it disturbs no successor. The final column flags critical activities, and those rows are highlighted so the critical path stands out at a glance.

The timeline chart plots each activity as a bar positioned at its early start and coloured red if it is critical and blue if it has float. Reading the chart top to bottom gives an immediate visual sense of which work drives the finish date and where the slack sits. Because the chart uses early dates, gaps between a bar’s end and the start of its successor represent the free float visible in the table.

Why the critical path matters for managing a project

The critical path is where management attention should concentrate. Shortening any non-critical activity does nothing for the project deadline — it only increases that activity’s float. To finish sooner you must shorten the critical path, and to avoid finishing later you must protect it. This is why status meetings that review every task equally waste effort: a one-day slip on a task with ten days of float is noise, while a one-day slip on a critical activity is a one-day slip to the whole project.

The float table also drives resource decisions. When two activities compete for the same crew or machine, the one with more float can usually wait, letting the critical activity proceed. This is the logic behind resource levelling and behind the everyday judgement calls schedulers make when reality diverges from the plan. Knowing the numbers turns those calls from guesswork into arithmetic.

Finally, the critical path is the starting point for schedule compression. Once you know which activities are critical, you can evaluate schedule crashing — adding resources to critical activities to buy time at the lowest cost — or fast-tracking, where activities that were planned in sequence are overlapped. Both techniques act only on the critical path, and both are the subject of dedicated tools in this project’s project-management library.

Compressing a schedule: fast-tracking versus crashing

Once the critical path is known, there are two classical ways to finish sooner. Fast-tracking overlaps activities that were originally planned in sequence — starting to install services, say, before the frame is fully complete. It costs no money but adds risk, because activities now run in parallel that were separated for a reason, and rework becomes more likely if the earlier activity changes. Crashing instead adds resources to critical activities — extra crews, overtime, a second shift — to shorten their duration directly.

Crashing always costs money and often suffers diminishing returns, since the tenth worker on a task adds far less than the second. The economic art of crashing is to buy time on whichever critical activity offers the lowest cost per unit of time saved, and to stop when the marginal cost of compression exceeds the value of finishing earlier. Both techniques act only on the critical path, which is why identifying it correctly, as this calculator does, is the prerequisite for either.

As you shorten critical activities, watch for a previously non-critical path becoming the new driver: compression often shifts the critical path rather than simply shrinking the old one.

The critical path in agile and hybrid delivery

It is sometimes claimed that critical path analysis belongs only to traditional, plan-driven projects and has no place in agile delivery. That is an overstatement. Within a single iteration or sprint the work is usually small and self-organising enough that a formal network adds little.

But at the programme level, where dozens of teams and external dependencies interact — a hardware component that must arrive before firmware can be tested, a regulatory approval that gates a release, a shared platform team whose output several product teams depend on — the logic of the critical path reasserts itself.

Hybrid delivery models therefore often apply CPM to the coarse-grained dependencies between workstreams while leaving each workstream free to plan its own detailed work iteratively. The method is not a relic; it is simply applied at the level where dependencies genuinely constrain the outcome.

Common mistakes when applying CPM

The most frequent error is confusing the critical path with the most important or most difficult work. The critical path is a purely mathematical construct: the longest path by duration. A trivial administrative task can be critical while a technically demanding task sits off the path with plenty of float. Manage by the numbers, not by intuition about importance.

A second mistake is ignoring that a network can have more than one critical path. When two parallel branches have identical length, both are critical and both must be protected. This calculator flags every zero-float activity, so multiple critical paths appear naturally in the highlighted rows. A third mistake is entering a dependency that creates a cycle — activity A waiting on B while B waits on A. Such a network is logically impossible to schedule, and the calculator will detect the cycle and ask you to fix it rather than return meaningless numbers.

Finally, remember that classic CPM assumes each duration is a single fixed number. Real activities are uncertain. When the durations are estimates rather than facts, a three-point technique such as PERT models that uncertainty on top of the same network. CPM gives you the deterministic skeleton; probabilistic methods add the flesh.

Where CPM is used

The Critical Path Method is industry-agnostic. In construction it schedules trades so that foundations, framing, services and finishes follow in a feasible order. In manufacturing and new-product development it sequences design, tooling, prototyping and validation. In software and IT it orders design, build, integration and test phases. In events, maintenance shutdowns and turnarounds it compresses tightly interdependent work into fixed windows. Anywhere activities depend on one another and time matters, CPM is the common language.

Because it is deterministic and transparent, CPM is also the foundation that project-management certifications teach first. The forward pass, backward pass and float calculations on this page are exactly what the PMP and CAPM examinations expect candidates to perform by hand. Using the calculator to check your manual work is one of the fastest ways to build fluency with the method.

In construction the method earns its keep because trades are tightly interdependent and mobilising them is expensive. Excavation must precede foundations, foundations precede the structural frame, the frame precedes the building envelope, and only then can services and interior finishes proceed. A single slipped foundation pour can ripple through every downstream trade, and the critical path is precisely the tool that quantifies how far that ripple reaches. Contractors use it to sequence subcontractors, to justify time-extension claims, and to decide where overtime or extra crews will actually shorten the job rather than merely cost money.

In manufacturing and product development the network describes the path from concept to launch: requirements, design, tooling, prototype, testing, certification and ramp-up. Because tooling and certification often have long, immovable lead times, they frequently sit on the critical path, and recognising that early lets a programme manager order long-lead items before the rest of the design is frozen. In software and IT projects the same logic sequences architecture, development, integration, testing and deployment, and it clarifies why adding developers to a non-critical workstream does nothing for a release date driven by a critical integration-and-test phase.

Maintenance shutdowns and plant turnarounds are perhaps the purest application, and not coincidentally the problem CPM was invented to solve. A refinery or power-station outage costs enormous sums for every hour it lasts, so the entire body of work is compressed into the shortest feasible window. The critical path defines that window, and every hour shaved from a critical activity is an hour the plant returns to production sooner. The same reasoning applies to event production, film and television schedules, and any endeavour where a fixed deadline and interlocking tasks meet.

Interpreting the timeline chart in depth

The chart beneath the results table is a compact schedule visualisation. Each horizontal bar is one activity, drawn starting at its early start and extending for its duration, so the horizontal axis reads directly as elapsed time in your chosen units. Bars coloured red belong to the critical path; blue bars have float. Because every bar is placed at its early start, the picture shows the earliest feasible schedule — the plan you would follow if you started every activity as soon as its predecessors allowed.

Two visual patterns are worth learning to spot. First, where a blue bar ends well before its red successor begins, the empty space corresponds to float that could absorb a delay. Second, where red bars line up end to end with no gaps, you are looking at the critical path marching across the timeline with no slack anywhere along it. A schedule dominated by an unbroken run of red bars is tight and fragile; one with many blue bars and generous gaps has room to absorb the inevitable surprises. Reading the chart alongside the float column turns two views of the same result into a fuller understanding than either gives alone.

Milestones, constraints and the project calendar

Real schedules include more than activities with duration. Milestones are zero-duration markers — a design freeze, a contract signature, a go-live — and you can model one in this calculator as an activity with a duration of zero that depends on the activities it summarises.

External constraints such as “must start on” or “must finish by” dates are imposed from outside the network’s own logic and are the usual source of negative float when they conflict with the calculated schedule. Finally, remember that CPM works in abstract time units.

Translating a duration of “twelve units” into calendar dates requires a working calendar that accounts for weekends, holidays and shift patterns; the network arithmetic gives you the number of working periods, and the calendar maps those onto real days. Keeping the logical network and the calendar mapping conceptually separate keeps both easier to reason about.

A step-by-step manual walkthrough

To trust the calculator you should be able to reproduce its numbers by hand at least once, and the six-activity network from Example 1 is a good vehicle. Write the activities down with their durations: A takes 3, B takes 4, C takes 2 and follows A, D takes 5 and follows B, E takes 1 and follows both C and D, and F takes 2 and follows E. The first job is the forward pass, which establishes the earliest each activity can start and finish.

Begin with the activities that have no predecessors, A and B, and give them an early start of zero. A therefore finishes at 0 + 3 = 3, and B finishes at 0 + 4 = 4. Move to C, whose only predecessor is A: its early start is A’s early finish, 3, so C runs from 3 to 5. D depends on B, so its early start is 4 and it runs from 4 to 9. Now E depends on both C and D, and here the maximum rule bites: E cannot start until the later of C’s finish (5) and D’s finish (9), so E’s early start is 9 and it runs from 9 to 10. Finally F follows E, starting at 10 and finishing at 12. The largest early finish anywhere in the network is 12, so the project duration is twelve time units.

Now the backward pass. Set the late finish of the last activity, F, equal to the project duration of 12, so F’s late start is 12 − 2 = 10. E must finish in time for F to start at 10, so E’s late finish is 10 and its late start is 9. E has two predecessors, C and D, and both must finish by E’s late start of 9, so the late finish of both C and D is 9. C’s late start is then 9 − 2 = 7, and D’s late start is 9 − 5 = 4. Working further back, A must finish by C’s late start of 7, so A’s late finish is 7 and its late start is 4; B must finish by D’s late start of 4, so B’s late finish is 4 and its late start is 0.

With both passes done, compute total float as late start minus early start for each activity. A: 4 − 0 = 4. B: 0 − 0 = 0. C: 7 − 3 = 4. D: 4 − 4 = 0. E: 9 − 9 = 0. F: 10 − 10 = 0. The zero-float activities are B, D, E and F, and reading them in order gives the critical path B → D → E → F, exactly what the calculator reports. A and C each carry four units of float because their branch is four units shorter than the parallel branch through B and D. Doing this once by hand makes the automated table on this page far more meaningful.

Activity-on-node versus activity-on-arrow

Two diagramming conventions have historically been used to draw project networks. In the activity-on-node (AoN) convention, which this calculator uses and which dominates modern practice, each activity is a box and the arrows between boxes represent dependencies.

In the older activity-on-arrow (AoA) convention, activities are the arrows and the nodes are events or milestones, often requiring artificial “dummy” activities to express certain dependency patterns. The mathematics of the forward pass, backward pass and float are identical in both; only the drawing differs.

Because AoN needs no dummy activities and maps cleanly onto the way scheduling software stores tasks, virtually all contemporary tools — and this one — adopt it.

Dependency types, leads and lags

The classic Critical Path Method assumes finish-to-start (FS) dependencies: a successor begins only after its predecessor finishes. That is the relationship this calculator models, and it covers the large majority of real scheduling logic.

Full-featured scheduling packages also support three other relationships. Start-to-start (SS) links two activities that can begin together once a trigger occurs. Finish-to-finish (FF) links activities that must complete together. Start-to-finish (SF) is rare and links the start of one activity to the finish of another.

Planners sometimes add a lead (a negative delay, letting a successor start before its predecessor fully finishes) or a lag (a mandatory wait, such as concrete curing before the next trade can work). When you build a network by hand for this calculator, you can approximate a lag by inserting a short dummy activity representing the waiting time, keeping every real dependency finish-to-start.

Near-critical paths and schedule risk

A path whose total float is small but not zero is called near-critical. These paths deserve almost as much attention as the critical path, because a modest overrun can turn them critical and shift the project’s driving sequence overnight. If your network shows one path at zero float and another at just one or two units, treat both as fragile. Reviewing the float column and sorting activities by how little slack they carry is a fast way to spot this risk. Projects with many near-critical paths are inherently harder to control, because there are more ways for the finish date to slip and fewer places to safely absorb delay.

Negative float can also appear when a schedule is given an imposed finish date earlier than the calculated project duration. In that situation the backward pass starts from the imposed date rather than the computed end, and activities that cannot meet it show negative total float — a quantitative signal of how much the schedule must be compressed to hit the target. This calculator computes float against the network’s own longest path, so negative float will not appear unless you deliberately model an earlier constraint by adding activities that force one.

CPM, PERT and Gantt charts compared

These three tools are often confused. A Gantt chart is a presentation device: a horizontal bar chart of activities against a calendar. It shows when work is scheduled but does not by itself compute the critical path or float; those come from the underlying network logic.

The Critical Path Method is that underlying logic — the deterministic calculation of dates and float from durations and dependencies. PERT, the Program Evaluation and Review Technique, extends CPM by replacing each single duration with an optimistic, most likely and pessimistic estimate, producing an expected duration and a variance so the schedule can be described probabilistically. In a mature planning process the three work together:

CPM and PERT compute the schedule and its risk, and a Gantt chart communicates the result to stakeholders. The timeline produced by this calculator is a lightweight Gantt-style view of the CPM result.

A brief history of the method

The Critical Path Method was developed in the late 1950s by Morgan Walker of DuPont and James Kelley of Remington Rand, who were looking for a way to schedule complex plant maintenance and construction so that expensive shutdowns could be minimised.

At almost the same time the US Navy, working with Booz Allen Hamilton and Lockheed on the Polaris missile programme, developed PERT to manage a project with tens of thousands of uncertain activities. The two techniques emerged independently but converged on the same network mathematics, and together they founded modern project scheduling.

More than six decades later the forward pass, backward pass and float calculations they defined remain unchanged, which is why learning them by hand is a durable skill rather than a passing fashion.

Critical chain and resource-constrained scheduling

Standard CPM assumes that whenever an activity’s predecessors are complete, the resources to perform it are available. Real projects rarely enjoy that luxury: the same crew, machine or specialist is often needed by several activities at once. When resources are limited, the schedule must be levelled, and the sequence that actually drives the finish date may no longer be the pure critical path — it becomes the resource-critical sequence, sometimes called the critical chain.

The critical chain method, popularised by Eliyahu Goldratt, adds buffers of time at the end of the chain and at points where feeding paths join it, rather than padding every individual activity. This calculator computes the classic, resource-unconstrained critical path, which is the correct starting point; resource levelling is a second step layered on top once the logical network is sound.

Understanding the pure critical path first is essential, because you cannot sensibly level resources against a schedule whose logic you have not yet validated.

Baselines, tracking and schedule variance

The critical path you compute at the start of a project is a plan, and a plan is only useful if you measure reality against it. Once work begins, managers save the initial schedule as a baseline and periodically update actual start and finish dates. Recalculating the network with actuals shows whether the project is tracking to plan, and crucially whether the critical path has shifted.

A common and dangerous surprise is that an activity which began with comfortable float loses all of it because upstream slippage consumed the slack, quietly promoting a previously safe branch to critical. Regularly recomputing the forward and backward passes — which this calculator makes instantaneous — is the discipline that catches such shifts before they become deadline misses.

In earned-value terms, schedule performance is tracked separately, but the network calculation is what tells you which specific activities to worry about.

Assumptions and limitations to keep in mind

Every model simplifies, and CPM is no exception. It assumes durations are known and fixed, that dependencies are correctly and completely specified, and, in its classic form, that resources are unlimited. It models finish-to-start logic cleanly and other relationships only with extra effort. It produces a single deterministic answer, which is a strength for clarity and a weakness for representing uncertainty.

None of these limitations makes CPM less valuable; they simply define where it fits. Use it to establish the logical schedule and to see the driving sequence, then reach for PERT when durations are uncertain, for resource levelling when capacity is constrained, and for schedule crashing when you must compress the plan.

Treating the critical path as the honest deterministic core of a schedule — neither more nor less — is the mark of an experienced planner.

Tips for working with larger networks

Small teaching networks have a handful of activities, but real project schedules can run to hundreds or thousands. A few habits keep large networks manageable. Give activities meaningful, systematic IDs so that the results table can be scanned quickly. Group related work so that dependencies stay local and the network does not become a tangle of long-range links.

Watch for activities with no successors other than the project finish and for activities with no predecessors other than the project start, since these are your true entry and exit points and any stray dangling activity usually signals a missing dependency. When you paste a large network into this calculator, the topological ordering it performs will surface any cycle immediately, which is often the fastest way to find a logic error that a visual diagram would hide.

Finally, remember that the critical path is a property of the whole network: adding or removing a single dependency can lengthen or shorten it in ways that are hard to predict by eye, which is exactly why an automated calculation is worth doing.

A short glossary of scheduling terms

Activity — a discrete piece of work with a duration. Duration — the time an activity takes, in consistent units. Predecessor — an activity that must finish before another can start. Successor — an activity that starts after a given activity finishes. Early start (ES) and early finish (EF) — the earliest an activity can begin and end, from the forward pass. Late start (LS) and late finish (LF) — the latest an activity can begin and end without delaying the project, from the backward pass. Total float — how long an activity can slip without delaying the project. Free float — how long it can slip without delaying any successor. Critical path — the longest path through the network, made of zero-float activities. Project duration — the length of that longest path. Milestone — an activity of zero duration marking a significant point. Keeping these definitions straight is most of what it takes to read any schedule with confidence.

How to use this calculator effectively

Start by listing every activity in your project with a short unique ID, a realistic duration in consistent time units, and the IDs of the activities that must finish before it can begin. Enter them one per line in the box above, then press calculate. If you are new to the format, press “Load example” to populate a working six-activity network and study how the input maps to the output. Read the project duration and critical path in the summary cards first, then scan the float column to see where slack exists. Export the table to CSV to share with your team, or save the page as a PDF for a schedule review.

Keep your time units consistent — do not mix days and weeks in the same network — and keep IDs short so the table and chart stay readable. If the calculator reports a cycle, trace your dependencies to find the loop, since a set of activities cannot each wait on the other. If it reports an unknown predecessor, you have referenced an ID that you did not define; check for typos. Once the network is clean, the results update instantly whenever you recalculate, so you can experiment with shortening critical activities and watch the project duration respond — an informal but effective way to explore where compression would pay off before committing to a formal crashing analysis.

Five worked examples of the critical path

Example 1: finding the longest path

A project has paths A→C→E = 3+5+4 = 12 days and A→B→D→E = 3+2+3+4 = 12… take durations A3, B2, C6, D4, E2. Path A→C→E = 3+6+2 = 11 and A→B→D→E = 3+2+4+2 = 11. When paths tie, both are critical. The longest path sets the project duration.

Example 2: the forward pass

Starting at 0, early finish (EF) = early start (ES) + duration. For A (ES 0, dur 3), EF = 3, so C starts at ES 3 and finishes EF 9. The forward pass gives the earliest each activity can happen.

Example 3: the backward pass

From the 11-day end, late finish (LF) = the next activity’s late start. Working back, E has LF 11, LS 9; C has LF 9, LS 3. The backward pass gives the latest each activity can slip without delaying the finish.

Example 4: total float

Total float = LS − ES (= LF − EF). For a critical activity like C, LS 3 − ES 3 = 0 float. For a non-critical activity B on the shorter path, float = 1 day — it can slip one day before it matters.

Example 5: what “critical” means

The critical path is the chain of zero-float activities: A→C→E. Delay any of them and the whole project slips; the float on B and D is the only slack the schedule has.

Three expert tips for reading a critical path

Manage the near-critical paths too

A path with just one or two days of float can become critical the moment a critical activity is crashed or a near-critical one slips. Watch low-float paths, not only the zero-float one.

Float belongs to the path, not one task

Two activities sharing a path often share the same float — if the first consumes it, the second has none left. Treat float as a shared budget along the path, not a per-task allowance.

Recompute after every change

Adding a dependency, changing a duration, or crashing a task can move the critical path to a different chain. Re-run the passes after any schedule change rather than assuming the path is fixed.

Frequently asked questions

Sources, disclaimer and editorial transparency

This calculator applies the standard Critical Path Method on an activity-on-node network: a forward pass (ES = max predecessor EF, EF = ES + duration), a backward pass (LF = min successor LS, LS = LF − duration), total float = LS − ES = LF − EF, free float = min successor ES − EF, with the critical path being the chain of zero-float activities and the project duration the maximum early finish. This is consistent with standard project-management references such as the PMBOK Guide. This calculator and guide are created and reviewed by the OpsCalculators team; see our Editorial Policy for how each tool is researched, built, and tested.

Results are accurate estimates for planning and education, not certified scheduling or contractual advice, and they assume finish-to-start dependencies, fixed activity durations, and unlimited resources. For uncertain durations use a three-point method such as PERT, and for resource-limited schedules apply resource levelling on top of this logical network. OpsCalculators.com is operated by MAFHH INTERNATIONAL LTD. Your data is processed in your browser and never stored; see our Privacy Policy.