Construct 3: The Complete Guide

If you want the shortest possible path from "I have a game idea" to "people are playing it," Construct 3 deserves a close look. There is no editor to download, no compiler to wait on, and — for the most part — no code to write. That makes it a favorite for educators, students, hobbyists, prototypers, and game-jam teams who care more about iterating quickly than about wringing out native performance. This guide explains what Construct 3 is, how its event-sheet model works, how it is priced, how it compares to Godot and GameMaker, and exactly how to go from a blank browser tab to a running, exportable game.

What is Construct 3?

Construct 3 is a browser-based 2D game engine, made by the studio Scirra, built around no-code visual programming. Instead of installing software, you open the editor at a web address and start building immediately — the entire engine, editor, asset pipeline, and preview runtime live in the browser. Instead of writing code line by line, you assemble game logic from event sheets: visual blocks made of conditions ("when this happens") and actions ("do this").

That combination — runs in the browser, programmed without code — is what sets Construct 3 apart. It removes two of the biggest barriers a newcomer faces: getting tooling installed and configured, and learning a programming language before you can make anything move on screen. A student on a locked-down school laptop or a Chromebook can open Construct 3 and build a working game in the same session, which is a large part of why the engine is so popular in education.

Crucially, "no-code" does not mean "no escape hatch." Construct 3 also supports JavaScript (and TypeScript) for users who want to write real code, and you can mix scripted logic with event-sheet logic inside one project. So beginners get a gentle on-ramp, while experienced developers retain a path to do anything an HTML5 game can do.

Is Construct 3 free?

Construct 3 has a free plan, but it is deliberately limited. The engine is subscription-based rather than a one-time purchase. As of 2024/2025, the free tier lets you learn and experiment but caps several things — for example, the number of events and layers a project can use — and it does not grant commercial-use rights. To remove those limits and to be allowed to sell your game, you subscribe to a paid plan.

At the time of writing, Scirra offers paid tiers along the lines of a Personal subscription (for individual creators and small teams) and a Business subscription (for larger organizations and education at scale). The paid plans unlock the feature caps and grant commercial rights. Because subscription pricing changes over time and varies by region, term length, and educational discounts, this guide deliberately avoids quoting a permanent dollar figure — check construct.net for the current numbers before you commit.

The practical takeaway: Construct 3 is free to learn and prototype with, and it is inexpensive to start with relative to a full toolchain, but it is an ongoing cost rather than a one-time one. If you stop subscribing, you keep your project files, but you lose the paid features and the right to publish commercially. For some developers the recurring fee is a deal-breaker; for others, the speed and zero-install convenience are well worth it.

What can you build with Construct 3?

Construct 3 is a 2D engine, and within 2D it is flexible. Its sweet spots line up with the kinds of games that benefit from fast iteration and broad reach.

2D games of many genres

Platformers, top-down shooters and RPGs, puzzle games, match-3 and arcade titles, endless runners, idle games, and visual novels are all well within reach. Built-in behaviors (more on those below) handle common movement and physics patterns, so you can stand up a controllable character in minutes.

Web and HTML5 games

Because Construct 3 is HTML5-first, web is its native habitat. Games run on a web page with no plugin, which makes the engine a strong fit for browser-game portals, embeddable games, marketing minigames, and itch.io web builds that players can try in one click.

Educational and prototype projects

The zero-install, no-code workflow makes Construct 3 a staple in classrooms and a quick way to validate a game idea. Many developers use it purely to prototype a mechanic before committing to a heavier engine.

What it is not for

Construct 3 is 2D only; there is no native 3D engine. It is also less suited to very large, systems-heavy, or performance-critical projects, where the HTML5 runtime and the engine's scope start to show their ceiling compared to native engines. Pick it for focused 2D games, not for an open-world 3D epic.

How Construct 3 works: layouts, objects, behaviors, and events

Construct 3's core model is small and consistent, which is exactly why beginners pick it up quickly. A project is made of a handful of building blocks that fit together predictably.

Layouts

A layout is a level or a scene — a 2D space where you place things. A title screen is a layout; level 1 is a layout; a settings menu can be a layout. You arrange objects visually inside a layout by dragging them where you want them.

Objects

The things you place are objects. The most common is the Sprite (an image that can animate), but there are many object types: text, tiled backgrounds, particles, audio, and invisible helper objects. Each object can have multiple instances in a layout — a hundred coin instances all share one coin object type.

Behaviors

A behavior is a reusable bundle of logic you attach to an object to give it a capability, with no code required. Add the Platform behavior and your sprite gets gravity, jumping, and ground detection. Add 8Direction and it moves in eight directions. Add Physics and it joins a rigid-body simulation. Behaviors are one of Construct's biggest time-savers, because common mechanics are a checkbox away.

Event sheets

Game logic lives on event sheets: ordered lists of events, where each event pairs one or more conditions with one or more actions. This is the no-code heart of the engine, and it is worth its own section.

Event sheets: no-code logic

An event sheet is where you program your game without writing code. Each row, or event, reads like a sentence: a condition on the left describes when something should happen, and the actions on the right describe what happens. You build these blocks by picking from menus rather than typing syntax.

For example, a single event might say, in plain terms: "When the Player sprite collides with a Coin: destroy the Coin, and add 1 to the Score variable." In the editor that is one event with a collision condition and two actions stacked beneath it. Events run top to bottom every tick, conditions are checked, and matching actions fire. Sub-events let you nest logic, and groups let you organize and toggle whole sets of behavior.

This model is powerful precisely because it is constrained. There is no syntax to get wrong, no semicolons, no type errors — you are choosing from valid conditions and actions, so the things you can express are always things the engine understands. For most 2D game logic, event sheets are genuinely enough, and many shipped Construct games use little or no JavaScript at all.

JavaScript and TypeScript in Construct 3

When you do want to code, Construct 3 lets you. The engine exposes a JavaScript scripting API (with TypeScript support), so you can write real code that runs alongside your event sheets or replaces them entirely for a given object or feature. You can run code on startup, hook code into events, and read or manipulate object instances directly.

Because the engine is no-code first, a typical "show me code" example is short. Here is a small script using the Construct scripting API: it runs once on startup, finds the first instance of the Player object, and nudges it to the right. It illustrates the shape of the API — runOnStartup, the runtime object, and instance access — without needing event sheets at all.

// Runs once when the project starts, before the first layout.
runOnStartup(async runtime => {
    // Grab the first instance of the "Player" object type.
    const player = runtime.objects.Player.getFirstInstance();

    if (player) {
        let speed = 120;
        player.x += speed;          // move 120 pixels to the right
        player.setAnimation("Walk");
    }

    // You can also subscribe to runtime events from script.
    runtime.addEventListener("tick", () => {
        // per-frame logic goes here
    });
});

The reverse direction works too: you can call a JavaScript function from an event sheet, or expose values from script back into events. In practice many teams build the bulk of the game in event sheets for speed and reach for JavaScript only where they need custom algorithms, third-party libraries, or logic that would be awkward to express as blocks. This "no-code by default, code when you need it" design is one of Construct 3's most distinctive strengths.

Platforms and export

Construct 3 is HTML5- and browser-centric, and its export options reflect that. The web is its first-class target: exporting to HTML5 gives you a game that runs on a web page with no plugin, ready to host anywhere or embed in a site.

From the same project you can also publish beyond the browser using wrappers:

Because every target is ultimately an HTML5 game inside a wrapper, the same project travels across platforms with little change — but it also means performance is bounded by the browser runtime rather than native code. Consoles and native 3D are not export targets. For 2D web and mobile games this model is a real advantage; for performance-intensive or platform-specific work it is a limitation worth weighing.

A short history of Construct

Construct began life as an open-source Windows application called Construct Classic, before Scirra rebuilt it as Construct 2, a Windows-only HTML5 game maker that earned a strong following among indie and hobbyist developers in the 2010s. Construct 3 followed as the modern, browser-based successor: instead of being a desktop install, the entire editor moved into the browser and shifted to a subscription model.

That move to the browser is the defining decision of Construct 3. It made the engine instantly accessible on any operating system — including Chromebooks and Linux machines that Construct 2 never supported — at the cost of requiring an account and a subscription for full features. Scirra has continued to ship regular updates, including a newer, faster runtime and the JavaScript/TypeScript scripting features that broaden the engine beyond pure no-code use.

Construct 3 vs Godot vs GameMaker

If you are choosing a 2D engine, Construct 3 most often gets compared with Godot and GameMaker. Here is an honest, high-level breakdown focused on the no-code and 2D angle. The right answer depends on how much you want to code, your budget, and how large your project will grow.

Short version: choose Construct 3 if you want the fastest no-code, zero-install path to a playable 2D web game; choose Godot if you want a free, open-source engine that also does 3D and scales further; choose GameMaker if you want a focused 2D engine with a real scripting language (GML) and first-party console export. It is also worth comparing against Unity if your ambitions point toward larger, asset-rich 3D projects, since Unity covers far more ground than any of these but asks much more of a beginner.

How to get started with Construct 3

Getting started with Construct 3 is about as low-friction as game development gets, precisely because there is nothing to install.

1. Open the editor in your browser at construct.net — the engine launches in a tab with no download or setup.
2. Create a free account if you want to save projects to the cloud and pick up where you left off across devices. You can also save project files locally.
3. Start a New Project, give it a name and a window size, and you land in the editor with an empty layout.
4. Optionally install Construct as a Progressive Web App so it gets its own window and works offline — handy, though never required.

System requirements are minimal: any reasonably modern browser on Windows, macOS, Linux, or ChromeOS will run the editor. There are no platform-specific build tools to configure for basic web export, which is a big reason classrooms and jam teams reach for it.

How to make your first game in Construct 3

Here is the shortest path from zero to a running, exportable game. None of these steps require writing code.

1. Open the editor. Go to the Construct 3 editor in your browser, sign in if you want cloud saves, and click New Project.
2. Add objects to a layout. Double-click the empty layout to insert objects — a Sprite for the player and a Tiled Background for the ground — then position them where you want.
3. Add behaviors. Select the player sprite and add the Platform behavior (and a Solid behavior on the ground). Your character now walks and jumps with no code at all.
4. Write logic on the event sheet. Open the event sheet and add an event: pick a condition such as On collision with Coin and actions such as Destroy Coin and Add 1 to Score. Each event reads like a sentence.
5. Preview and iterate. Click Preview to run the game instantly in a new browser tab. Adjust events, behaviors, and the layout, then preview again — there is no compile step, so the loop is near-instant.
6. Export a build. Open Menu > Project > Export and choose a target — Web (HTML5) to host or upload to itch.io, desktop via NW.js, or mobile via Cordova — and you have a build to share.

From there the loop is the same as in any engine: add objects and layouts, attach behaviors, wire logic on event sheets, preview, and iterate. Construct's instant preview and zero build time make that loop especially fast, which is why it shines in jams and classrooms.

Pros and cons of Construct 3

Games made with Construct

Construct's catalog skews toward smaller indie, web, and HTML5 games, educational titles, and game-jam entries rather than big-budget releases — and that is worth being honest about. Where it has clearly proven itself is the browser-game and mobile-casual space: many titles on web-game portals, ad-supported HTML5 games, and quick mobile releases were built in Construct, and the engine has a long track record powering classroom projects and jam submissions that punch above their weight. A handful of Construct games have also found commercial success on Steam and mobile stores. If your goal is a polished 2D web or mobile game shipped quickly, Construct's track record is encouraging; if your goal is a sprawling AAA production, this is not the engine's lane.

Learning Construct 3: a roadmap

A sensible path for a newcomer:

1. Do the official beginner tutorial in Construct's manual. It teaches layouts, objects, behaviors, and event sheets by building a small game in one sitting.
2. Internalize the event model — conditions, actions, sub-events, and groups. This is the single most important concept in the engine.
3. Learn the common behaviors (Platform, 8Direction, Physics, Bullet, Solid) so you reach for them instead of reinventing movement.
4. Rebuild a simple known game (Pong, a one-screen platformer, a coin-collector) to practice tying objects, behaviors, and events together.
5. Try a little JavaScript once you are comfortable, so you know where the no-code wall is and how to get past it.
6. Ship something small. Export an HTML5 build, put it on itch.io, and watch how it behaves on devices and browsers that are not yours. That last step teaches more than any tutorial.

If you build with Construct 3, our Construct 3 solutions page walks through how to wire crash and bug reporting into a Construct project, and the Bugnet blog covers a range of focused, practical game-dev fixes that apply across engines.

Shipping a Construct 3 game: the part tutorials skip

Building the game is one thing; keeping it stable once real players have it is another. A Construct 3 game that runs flawlessly in your browser can still break on a player's older phone, an unusual browser, a low-memory device, or a save state you never hit in testing. Because the game runs as HTML5 across a huge range of devices and browser versions, the surface area for "works for me, not for them" is enormous. When something goes wrong, a one-star review that just says "froze on level 3" gives you nothing to act on.

The bug you can't reproduce isn't gone — it's just invisible until you capture it from the player's device.

The fix is to capture failures automatically from the player's device. With the right reporting in place, each crash or error arrives with its full stack trace, the browser and OS, the build number, and a breadcrumb trail of what the player did right before it broke. Identical failures fold into a single grouped issue ranked by how many players each one hits, so your worklist sorts itself worst-first instead of arriving as a stream of vague complaints.

That is exactly what Bugnet does for Construct 3 games: a small SDK captures every error with full context, groups duplicates, and ties each issue to the build it first appeared in — so you fix the problem that hurts the most players first and confirm it is gone when its signature disappears from the next release. It is the difference between guessing at a bad review and shipping a fix you can prove worked.

Compare other game engines

Still deciding? These companion guides go just as deep on the other major engines, and our hub compares them side by side:

• Best game engines for indie developers — the side-by-side comparison and decision guide.
• Godot game engine — free, open-source, great for 2D and indie.
• Unity game engine — the broad, asset-rich industry standard.
• Unreal Engine — best-in-class high-end 3D.
• GameMaker — fast, focused 2D development.
• Pygame — Python library for learning game development.

Frequently asked questions

What is Construct 3?

Construct 3 is a 2D game engine made by Scirra that runs entirely in your web browser, with no installation required. It is built around no-code visual programming using event sheets, where you define game logic as blocks of conditions and actions. It also supports JavaScript and TypeScript for developers who want to write code, and the two approaches can be mixed in the same project.

Is Construct 3 free?

Construct 3 has a free plan, but it is limited. As of 2024/2025 the free tier caps things like the number of events and layers you can use and does not permit commercial use. To remove those limits and gain commercial rights you subscribe to a paid Personal or Business plan. Because the pricing is subscription-based and changes over time, check construct.net for current figures.

Do you need to know how to code to use Construct 3?

No. Construct 3 is designed so you can build a complete game without writing any code, using event sheets made of conditions and actions. This makes it one of the most beginner- and non-programmer-friendly engines available. If you do want to code, Construct 3 also supports JavaScript and TypeScript, and you can mix scripted logic with event-sheet logic in the same project.

What can you build with Construct 3?

Construct 3 is a 2D engine, so it is well suited to platformers, top-down games, puzzle games, arcade games, and visual novels. It is HTML5-first, which makes it excellent for web games, but it also exports to desktop (Windows, macOS, Linux via a wrapper such as NW.js) and mobile (Android and iOS via Cordova-based wrappers). It is not a 3D engine and is not the right tool for large, highly complex projects.

Is Construct 3 good for beginners?

Yes. Construct 3 is one of the fastest paths from idea to playable game for non-coders. Because it runs in the browser with nothing to install and uses readable event sheets instead of code, it is widely used in education, for prototyping, and at game jams. Beginners can build and test a working game in a single sitting.

Can you use JavaScript in Construct 3?

Yes. Construct 3 supports JavaScript and TypeScript through its scripting API, so you can write real code alongside or instead of event sheets. You can attach scripts to events, run code on startup, and manipulate object instances directly. This gives experienced developers an escape hatch from no-code while keeping the rapid event-sheet workflow for everything else.

What platforms can Construct 3 export to?

Construct 3 is HTML5- and browser-centric, so its primary export is the web. From the same project it can also publish to desktop (Windows, macOS, and Linux through a wrapper such as NW.js) and to mobile (Android and iOS through Cordova-based wrappers). It does not target consoles directly or export native 3D games.

Is Construct 3 good for commercial games?

It can be, especially for 2D web and mobile titles, game-jam entries that grow into products, and educational games. Commercial use requires a paid subscription. Its catalog skews toward smaller indie, web, and HTML5 games rather than big-budget releases, and for very large or performance-intensive projects a native engine like Godot or GameMaker may scale better.

Pick the engine that gets you shipping. For non-coders and fast 2D web games, that engine is often Construct 3 — and the rest is just keeping it stable once players have it.