Learn how to make games from scratch with no programming

Open the stencil application and explore kits to start a blank flash game. Name the project, write a description, and set the screen size to 640x480 to create your game.

Add an actor to your game, name it, and open its properties to begin customization. Create an animation by adding a frame and selecting a PNG image, such as star.png.

Learn to add a scene, place an actor, and customize with tile or pixel sizes, color options, and gradients, then create and name the scene.

Learn how to add actors to a scene by selecting the player, placing it in the scene, and running a test game to see the result.

Learn to add events to an actor using inputs, click on actor, and set pressed on self to kill self, then test to see the actor delete on click.

learn how to brainstorm and document ten reusable events you can assign to an actor to organize ideas for gameplay in a no programming game creation workflow.

Explains actors and events in a visual stencil-based game maker. Learn to define conditions and actions, using images, mouse, keyboard, and timers to spawn enemies, pause, or destroy actors.

Explore Stencyl's visual programming, using design mode to create actor behaviors and events. See how code appears in the preview and learn to attach behavior to actors without typing.

Learn how import libraries power code, examine common code blocks and headers, and explore when updating, when drawing, and when created within a live preview.

Explore how shapes with bumps and hexagons in stencil fit together, and why only certain code blocks cooperate to create working configurations, avoiding loose fragments and boolean issues.

Learn how game loops run code in an always block with an update method, at a frames-per-second rate, to move an actor across the screen by updating its x position.

Discover how to place objects on screen using x and y coordinates and when created to run code once, versus always running code every frame in the game loop.

Identify actions that run continuously and actions that trigger on object creation in the always and created fields. Learn to distinguish running checks from one-time events when building game objects.

Identify how attributes store game data and differentiate global and local scope in Stansel, then create and label variables with initial values for score and health.

Select an actor and create a local attribute to store per actor data. Local attributes assign properties like individual zombie health, avoiding global variables that apply universally.

Learn to set and update game attributes like score and health, initialize health to 100 and score to 10, and use get plus 10 to increment the score.

Explore getters and setters to access and modify data in game attributes, such as reading the current score and updating it by adding 10.

Develop a simple game by documenting a clear game design document, outlining features, programming needs, and art assets, then manage scope from design to release to ensure a releasable product.

Create a new blank game called star collect, set 640 by 480, import two actors (goldstar and red star), build a game scene, place the actors, and test.

Set up your game scene by applying vertical gradients and carefully chosen background colors to enhance contrast with foreground graphics, learning practical tips to avoid stark black-and-white palettes.

Learners implement rotating stars by updating during the on update event, turning gold and red stars by one degree in opposite directions to create clockwise and counterclockwise motion.

Add click interactions to destroy a star by detecting mouse input on the actor and triggering a kill self action, test the game, and debug the is pressed event.

Explore adding a no-code spawn feature by creating a game scene behavior that periodically spawns red and gold stars, assigns lifetimes, and destroys them to balance screen clutter.

Set up a score display by creating and labeling a font in stencil, choosing a typewriter style, selecting an off-white color at size 36, and optionally adding a custom font.

Create and set up a game font to display the score, choosing the typewriter font, color, and size, with an option to add a custom font.

Display the score by drawing text at the top-left corner using a font set in styles, then save to activate it. Test the game to confirm the score appears.

Create a score attribute initialized to zero in the game attributes. Bind the score to a text element and display it with a space for proper formatting.

Add scoring to your first game by increasing the score when the gold star is clicked and decreasing it when the red star is clicked.

Make a small change to the game mechanic by requiring clicks on gold stars and avoiding red stars. Avoid large production changes to prevent breaking the project.

Add a timer by creating a time attribute starting at 0, display it as on-screen text, and increment it every second to track game time.

Demonstrates finalizing a game design document for a simple, playable game and outlines future enhancements like time multipliers, combos, and collectible items such as a blue star to boost score.

Brainstorm many uses for each game event using divergent thinking. Create a simple test scene with a gray 36 point typewriter font and a scene behavior to draw text.

Learn how to find the x and y coordinates of an actor on screen using x center and y center, and apply these values to position game objects.

Explore using set x and set y to place an actor at precise coordinates, relative to the actor or the scene, and identify five gameplay events that snap positions.

Learn how if statements control game behavior by killing the self object when on screen, with examples using onscreen conditions, hexagon shapes, x coordinates, and simple collision logic.

Set an actor's direction in degrees, randomize its angle between 1 and 359, and use that direction in AI to determine where a game object is headed.

Learn how to rotate an object clockwise or counterclockwise in sensel, use always for continuous rotation, and implement simple if-else logic with degree changes.

Learn how to use if, otherwise, and otherwise if statements to control game actions with a money attribute, including testing, compiling, and avoiding excessive else logic.

Explore practical logic for game development by using if statements, not equal, and or operators to compare variables like money and score, with booleans and nested conditions.

Learn to use relational operators such as <, >, <=, and >= in game logic, avoid off-by-one errors with lives and game over, and find five practical use cases.

Explore how if statements drive game logic, from simple to complex conditions, using and/or combinations to determine game over based on lives, money, score.

Master boolean logic using local attributes like health and damage, checking if a value exists or not, and creating boolean variables to drive if and else if statements.

Learn how to create and use lists in your game projects, add text items like name, and organize by index for RPG data such as hit points and damage.

Explore how if, otherwise if, and otherwise statements drive actor behavior using regions, on-screen status. Enable alive state and animation checks for bottom jump, left wall jump, and top grapple.

Manage game flow by pausing and scene transitions, ensuring everything stops or continues as needed. Access live and local attributes and quickly reach game attributes via quick options.

Use definite loops to spawn multiple game actors with a repeating block in flow looping, test at positions like 200 and 200, and manage memory to avoid crashes.

Learn to run code every x seconds to spawn actors, test a two-second interval, and use the created and update sections in a game loop with a spawn time attribute.

Learn debugging basics by printing to the console and using comments to document logic, explain attributes for numbers, and keep your game code clear when counting and text.

Master basic debugging techniques by customizing console output colors, optionally disabling drawings, and trying the optional advanced code section to input values.

Explore managing actors in game development by comparing kill self and recycled self, understanding memory and garbage collection, and recycling actors on mobile to optimize resources.

Learn how to use for each loop to act on every actor on the screen, adjusting properties like position and rotation, and test results directly in the scene.

Learn to control on-screen actors by looping over each actor in a region and by actor type, applying rotations and properties to targeted groups.

Create and manage actor groups with a for each loop in senseful, grouping players, enemies, and power ups. Use group collisions to delete members by triggering a kill self action.

Discover how to use the region properties to create, position, resize, move, and delete regions at specific x and y coordinates, including 100 by 100 pixel regions.

Explore how gravity uses the x and y axes to move objects. Positive x moves right and positive y moves down, while negatives reverse direction or move up.

Develop a simple gravity game in stencil by adding a boolean gravity attribute, toggling gravity on mouse press and release, and updating gravity to move stars while destroying off-screen objects.

Learn to read the screen size in pixels, obtain the width and height, and center an actor by dividing values by two and applying screen behavior.

Explore tile sets and grid properties, using 32 by 32 tiles with a 32-pixel height. Tile width and height govern snap-to-grid and divisibility by 32 with rounding up.

Practice implementing scene transitions, applying a fade in of three seconds, and conditionally switching scenes based on the scene name.

Explore how to access and use the camera in Stencyl for 2D games, including x and y coordinates, camera movement, and spawning actors near the camera.

Move the camera in a 2D game by panning to a location or actor, and implement simple cut scene logic using a boolean flag to trigger movement.

Enable screen shake effects, adjust duration and intensity, test during gameplay, learn when to stop shaking, and toggle full screen on or off to manage resolution.

Learn to use layers to organize game objects into background, playable objects, and foreground; control visibility and opacity with fade effects and label layers for clarity.

Set the offscreen bounds in this engine using origin 0,0 as reference. Expand bounds beyond the visible area to spawn objects offscreen and have them move toward the center.

Explore scene transitions in a no-programming workflow, experimenting with bubbles out, reciprocal transitions, timing from 1 to 3 seconds, and testing via click to create dynamic game flow.

Reload a scene by dragging a second object and selecting a transition type and duration, then spotlight out and in to trigger a reset, useful for death sequences.

Learn to switch between scenes with a crossfade, starting at three seconds and dialing to 0.5 seconds for a quick 3.5-second transition; note this crossfade is flash-only.

Learn how to crossfade and reload scenes by creating a test actor after transitions, position it, and apply fade in and out to verify scene changes.

Create an actor after a transition to populate subsequent scenes, control its position and a three-second fade-in, test across scenes, and avoid using this method to spawn the player.

Use if statements to pause the game during scene transitions and control audio, learning practical game flow management as scenes switch.

Explore the control center in Stansel, mapping controls by name to keys like left, right, up, down, and actions one to three, and add a new control with a key.

Learn to implement simple movement using up, down, left, and right controls with if statements and otherwise if, updating the actor's x and y in the always block.

Learn how holding shift with left or right inputs increases speed, and how to wire these shift-and-direction conditions in a flow graph.

Learn to use mouse input to rotate an actor on mouse down, handle pressed and released, set the actor to mouse position, hide the cursor, and simulate a key press.

Learn basic arithmetic in game creation by using addition, subtraction, multiplication, and division to manage points, damage, and screen layout, while exploring negative numbers, negation, remainders, and rounding.

Learn to create random numbers in games by selecting attributes, update drawing logic, and distinguish integers from floats, including a 0 to 1 random float for percentages, colors, and alpha.

Apply increment and decrement controls to modify a local number, increasing or decreasing it by one with a click, and connect changes to scoring.

Continue exploring math concepts essential for making games from scratch with no programming, focusing on practical applications and step-by-step problem solving.

Explore math part 5 as part of learning to make games from scratch with no programming.

Text is the visual representation of characters and cannot be used for math. It contrasts text attributes with number attributes and demonstrates a 1 plus 1 example.

Master adding sounds with the stencil forge, import sound effects, set music, and stop sounds between scenes. Adjust volume, fade in, and use channels for multi-track audio.

Add a trigger to an event by wiring a trigger event in a behavior to call code in another class, then shake the screen when the event fires.

Learn to trigger an event in another behavior by creating a custom event and wiring it to a trigger. Test to verify the event fires in the target behavior.

Explore how triggers behave across scene-related behaviors, diagnose simple bugs in both code and non-programming engines, and see a working example that reliably fires an event.

Pull attributes from another behavior into the current one, such as damage and health, and verify case-sensitive names to ensure proper data flow and synchronization.

Learn to set a local attribute by selecting a value from a behavior, choosing the correct attribute name, and setting it (for example to 20), then test the game.

Learn to access and modify actor and scene attributes within a scene, retrieving text from behaviors and applying the same update logic to both actor and scene.

Learn how to enable and disable behaviors attached to actors and scenes using behavior names and if statements to control gameplay.

Learn to open a link in Stencyl by adding a web browser, triggering the URL when an actor is pressed to launch in the native browser.

Learn how to post data to a website, briefly illustrating posting a player's name to Twitter, while focusing on saving and loading game attributes with a simple save feature.

Attach a background to a scene in stencyl, adjust horizontal and vertical scroll speeds to create parallax, and tile repeating backgrounds to avoid gaps during testing.

Discover how tile sets create grid-based scenes, arranging tiles to build platforms and backgrounds in stencil forge using the area 51 tile set.

Celebrate progress and preview next steps as you learn how games function, start designing more games, and explore sensel templates that save you work.

Learn how to download free graphics assets for your game by following links, extract the star assets onto your desktop, and prepare for next tutorial in the no programming course.

Create a simple star-collecting game from a blank project in stansel, naming it and setting the 640 by 480 canvas to demonstrate quick game setup.

Add actors and color-changing stars to a simple game, where players click the color-matching stars that move toward a main star, and learn to create scenes and assets.

Learn to make the stars rotate by creating a rotate stars behavior, attaching it to all star actors via a game attribute called star rotation playable, and testing the result.

Learn to fix collisions by using a circle collider with a 48 radius for all stars, and recognize busy work as a normal part of game development.

Configure the main star with five animations using Green Day, Bluestar, Red Star, and Goldstar, rotate counter-clockwise by 0.5, and replace collision bounds with 84 circles while enabling physics.

Increment the main star color every three seconds using a color variable and an if statement, and reset to one when the value reaches six, since there are five colors.

Use an if statement on the main star color attribute to switch the actor’s animation to black, blue, red, or gold, and batch changes for faster production.

Learn how to make stars move by applying a random force with push self in x and y directions, using a 0-359 degree range, then test and auto-delete off screen.

Use the bounce off screen attribute in actor behaviors to keep stars on screen, applying it to Black Star, Bluestar, and Goldstar, then test with a 30 force push.

Add a circular boundary by creating a barrier actor, making its image transparent, and setting it immovable; group it as walls and include it with doodads.

Apply a bounce by triggering a push force on star barrier collisions, using a stars behavior and two bounce zones to keep stars moving around the barriers.

Learn to move a star toward the center by clicking it, using a sharp push toward set coordinates, and address color-based selection and collision handling in the next tutorial.

Disable collisions for the star character by creating a no-collision animation, removing the collision box, and aligning animation names for use with the Stars behavior.

Change the animation by setting the star behavior's draw button to no for all stars, ensuring the name matches exactly to prevent crashes, then save and test the collisions.

Learn how to make a star disappear when clicked by adjusting the flow time and destroying the object after a brief delay, with iterative testing to ensure responsive removal.

Add the star color functionality by wiring the main's star color attribute to color choices using if statements and equal signs, mapping five colors and updating the score.

Learn how to display a score on screen by creating a score font, using a typewriter style at size 36, and drawing the score with a global score attribute.

Add score functionality by updating the star's game attributes to increment the score by 10 when clicked, using a simple arithmetic operation.

Learn to add star color functionality in a no-programming game from scratch, including color-based type checks and ordering green, black, blue, red, and gold stars.

Learn to implement per-star boolean variables to control spawning in a simple game, marking each star as alive or dead and respawning when needed.

Set the is alive boolean for every star when created, using the event created and game attributes to safeguard logic across black, blue, green, red, and gold stars.

Implement the isAlive logic by setting isAlive to true when alive and to false when destroyed for blue, red, and gold stars, then introduce a spotter to spawn the object.

Spawn a green star when is alive green is false, using a when updating block and a one-second delay with random on-screen coordinates.

Add the rest of the logic by duplicating code blocks, assigning color attributes (black blue gold red), using otherwise if statements, and setting the correct actor type, then test.

Add a timer attribute and a draw text to show elapsed time, updating every second. Replace the score with the timer and ensure it increments smoothly, with 0.01 increments.

Learn to give players a reason to click the right star by scripting per-star input, checking the main star color against the target, and subtracting ten from timer when wrong.

Create a simple leveling system that advances when a timer hits a value, increasing points per level, and style the display with a large typewriter font, color, and stroke.

Implement a timer-driven leveling system with if and else if statements to update a level attribute and on-screen text as the timer hits 0–50 and 100–150, creating level 2 and beyond.

Add a simple leveling mechanism by duplicating a modifier to make the score increase by the current level plus ten for each press, illustrating scalable modifiers for more complex games.

Learn to create a collectible game from scratch without programming, download large graphics sets, resize to avoid distortion using Mac Preview or a free editor on other platforms.

Resize game assets on a Mac by using tools and adjust size, setting the player to 50 and applying the same 50 size to coins and rings.

Resize game assets in gimp by using image scale to 50 pixels, then export and replace. Apply the same scale to related images.

Create a blank game from scratch, add animated coin and ring actors with multiple frames, build a scene, and run a simple coin-collecting game to see animation.

Add the player to the scene and make it follow the mouse by setting its x and y to the mouse coordinates; place the gem on screen distinct from coins.

Adjust the offset by subtracting half the actor's width and height so the cursor sits at the center of the object it follows.

Implement collision-based collectibles by creating a collectible logic behavior, attaching it to coins and rings, and deleting the actor upon colliding with the player.

Add score, timer, and modifier attributes to a heads-up display with a custom font. Implement a scene behavior to draw, place, and attach heads-up display to the scene for testing.

Add score logic from collecting items, creating a level attribute, and incrementing the score by level plus a modifier when a collectible hits the player.

Learn to set up a timer in your game, updating every 0.1 seconds via a timer variable and game attributes, with an initial 0.1 to slow the timer.

Add a level-up system driven by score thresholds, starting at level 1 and advancing to level 2 and 3 within a defined score range, with an otherwise branch for testing.

Learn to implement a modifier system alongside timer-based triggers using if statements to adjust the modifier and score, creating ongoing point gains and escalating levels for more addictive gameplay.

Learn to implement spawn logic for coins and rings using scene behavior and a do every loop, create spawn time attributes, and define separate actor types for random locations.

Add the cannot accept screen behavior to the player to prevent leaving the screen. See that the mouse and player stay within bounds and follow the game logic.

Prototype multiple games by expanding a simple template, brainstorm 10 ideas for game mechanics, and explore timers, levels, and scoring to practice core game design with no programming.

Create a new achievement, customize its font and color, and save it. Unlock it with a score threshold and a boolean flag, then display 'achievement unlocked' when true.

Explore physics and collisions in the catapult template, controlling movement, gravity, rotation, and mass. Adjust material properties like friction and bounciness, and tune dampening and continuous collisions.

Configure collision shapes for game objects by choosing box, circle, or polygon, adjusting exposition and radius, editing vertices, and using sensors and groups, noting concave collisions are not supported.

Explore the free templates in stencil, focusing on the run and jump template and a space shooter, by playing each example for five minutes and reviewing the code.

Download the source code and the jump and run extended, run it, and press play to explore the game features as we discuss level design.

Create a new run and jump test game at 800 by 600, then fix a syntax error by removing the on rails block so it runs.

Explore level design basics as the instructor walks through designing a level using a demo scene, outlining the actors, behaviors, and workflow of a level designer.

Design a prototype level by placing tiles, setting heights, and adding a sky gradient with a start and finish. Add slopes, test jump rhythm, and use shift to fill terrain.

Add a background layer to the level by placing trees, grass, and waterfalls behind the front layer, using shift to grid align, and create a waterfall layer.

Explore a wide range of level objects—including jumping enemies, spikes, platforms, water, and fish—and experiment with templates to design and test diverse level layouts.

Design ten levels using the provided template to practice level design alongside programming and art. Seek friends’ feedback, design more levels weekly, and continuously expand your game creation skills.

Learn how to release small, addictive games by four stage planning, choose a viable idea, and monetize through selling games, sponsorship, ads, and source code.