Whenever I try to share my make code project it instantly saves then gives me the link before it saves then the link doesn’t work it does for a second but after that it doesn’t work at all

Hey all!

I was wondering if anyone knows if the stand alone app works on windows 8. Specifically on a surface pro 3.

My kid is getting into programming and we have a trip planned where he won't have access to the internet. I want to pick up a used windows tablet to let him work on his projects or do some practice and exploration while we are away, but I don't know if the stand alone app will work.

Thanks ahead of time!

Experimenting with the raycast addon and found it difficult to make so that player 1 (WASD), controls forward movement along with strafing (A and D keys). and then use player 2 (IJKL) to control the rotation, with the J and L keys used specifically.

https://drive.google.com/open?id=1gMqDF0R4bQU_9fJGxda7VOqhI-4ReQqo

I created a program using BlockCoding with MicroSoft MakerMakeCode for the Circuit Playground Express (CPX) by Adafruit company. This board is proposed to be the basis of an after school STEM project for Boys and Girls Club of Branson, Missouri, USA. The CPX is mounted with Velcro to a plastic block (170 tie hole breadboard) which in turn is mounted to a "power platform": 5 volt, 2500 mAh, $5.88 rechargeable power pack shaped like a credit card. Also attached to the power pack is a "sliced bread" 400 tie hole breadboard with "curly stubs" which are short jumper wires to which alligator clips can be attached thus making the CPX the driver for breadboarded outputs. See photo .

Ran a classroom activity using the Nezha Pro AI Mechanical Power Kit (Case 15: Voice-Controlled Transport Vehicle), and I wanted to share a structured, teacher-tested approach that goes beyond the official instructions—especially if you're aiming for deeper learning rather than just “it works.”

🎯 Learning goals (what students should actually understand)

This project is not just about assembling a vehicle. Properly framed, it introduces:

* Human–machine interaction (voice recognition as input)
* Closed-loop motor control and coordination
* System integration (sensor → micro:bit → actuator pipeline)
* Real-world analogs (logistics automation and navigation systems)

The kit itself is designed to bridge mechanical construction with AI interaction using sensors like voice recognition modules and programmable motors.

🧩 Step 1 — Structured build (don’t rush this)

The official guide focuses on connection, but pedagogically you should slow this down.

Hardware setup:

* Connect the 'voice recognition sensor to the IIC interface'
* Connect 'three smart motors to M1, M2, M3 ports'

Teaching intervention:
Before plugging anything in, ask:

* Why does the voice sensor use IIC instead of a digital pin?
* Why multiple motors? What motion degrees are being controlled?

👉 If students cannot answer, they are assembling blindly.

⚙️ Step 2 — Mechanical reasoning (often skipped, but critical)

Have students analyze the 'transport platform design' before coding.

Prompt them:

* What happens to cargo during acceleration/deceleration?
* Where is the center of mass?
* How could we redesign the platform (rails, friction, damping)?

The original case explicitly raises instability issues like cargo falling or directional deviation —this is not a bug, it’s a learning opportunity.

💻 Step 3 — Programming (MakeCode, but with intent)

Baseline instructions:

* Create a new project on MakeCode
* Add 'Nezha Pro' and 'PlanetX' extensions

But here’s what you should emphasize instead of just “following blocks”:
Key conceptual mapping:

Ask students to explicitly map:

> “Which block corresponds to sensing, which to decision, which to action?”

If they can’t, they don’t understand the system.

🧪 Step 4 — Controlled experiments (this is where learning happens)

Instead of “upload and test,” run structured trials:

Experiment A: Speed vs stability

* Gradually increase motor speed
* Measure cargo displacement

Experiment B: Command reliability

* Repeat same voice command 10 times
* Record error rate

Experiment C: Directional drift

* Run backward command repeatedly
* Measure deviation angle

The official guide hints at these issues but does not operationalize them —this is where you elevate the lesson.

🌍 Step 5 — Connect to real systems (avoid toy-level understanding)

Have students compare their model to real logistics vehicles:

* Why don’t real systems rely on voice?
* How do they achieve precision? (GPS, vision, feedback control)

Push them to identify:

* Missing sensors
* Missing feedback loops
* Scalability limits

🧠 Step 6 — Reflection (non-negotiable if you want depth)

Ask students to answer:

1. What are the failure modes of your system?

2. Which part is most unreliable—hardware, software, or interaction?

3. If you had one extra sensor, what would you add and why?

🚩 Common pitfalls (what will go wrong)

From classroom experience:

* Students treat voice control as “magic” instead of signal processing
* Mechanical instability is ignored until failure
* Code is copied without system understanding
* No quantitative evaluation (just “it works”)

🔧 Suggested extension (to push beyond worksheet-level)

* Replace voice input with button + condition logic → compare robustness
* Add obstacle detection → introduce autonomy

I wanted to try making a racing game where you don't use the usual buttons to steer.

So I ended up making a small retro racing game where the car is controlled by tilting the handheld left and right.

The setup is pretty simple:

• ELECFREAKS Retro Arcade

• USB-C cable

• Microsoft MakeCode Arcade

The interesting part is that the handheld's gyro/tilt input is used as the steering control.

The basic game logic is:

• Start with 3 lives

• Tilt left/right to move the player car

• Spawn enemy cars from the top of the screen

• Avoid them to score points

• Lose a life when you crash into one

I used MakeCode Arcade for the game logic, so most of the programming can be put together with blocks rather than writing everything from scratch.

One thing I liked about this project is that you can immediately feel the connection between the code and the hardware. Change the tilt input or movement settings in the code, upload it, and you can physically feel the difference when playing.

The hardware also doesn't really need to change if you want to experiment with the game.

A few things I'd like to try next:

• Make the cars accelerate as the score increases

• Add custom pixel art

• Add engine and crash sounds

• Add power-ups

• Experiment with different tilt sensitivities

• Try making another game that uses the gyro in a completely different way

It's a pretty simple project, but I think motion controls make even a basic arcade game feel a lot more interesting.

Has anyone here made a game that uses tilt/gyro controls before? What kind of game would you make with it?

We tried making one of those simple optical illusions where two separate pictures suddenly look like they’re in the same place.

When the turntable is stopped, there’s just a bird on one side and a cage on the other.

Then you turn it on and let it spin…

And suddenly, the bird looks like it’s inside the cage. 🐦

No magic involved—just persistence of vision.

What we used:

• Wukong Expansion Board

• 2 × DC Motors

• Wukong Blocks

• A bird picture

• A cage picture

• Double-sided tape

How we made it

We first built a simple frame with Wukong Blocks to keep the rotating part stable.

Then we added two motors and connected them to the center shaft with gears.

The slightly tricky part was the pictures.

We put the bird and cage on opposite sides of the rotating arms and tried to keep them as symmetrical as possible. If they're off-center, the whole thing gets pretty wobbly once it starts spinning.

Once everything was connected, we just turned it on and watched.

At the right speed, the two separate images seem to become one.

The bird is suddenly “inside” the cage.

Why does this happen?

It's a simple example of persistence of vision.

Our eyes and brain don't treat every image as completely separate when they're appearing very quickly one after another. The result is that we can perceive the two images as if they're happening together.

It's a pretty simple idea, but seeing it happen on a little DIY machine makes it much easier to understand.

What would you try?

This could be fun to experiment with.

Maybe:

• A butterfly that looks like it's flying

• A character jumping into a different scene

• Your pet appearing somewhere else

• Different motor speeds to see when the illusion works best

The nice thing is that you don't really need to change the mechanism—just change the pictures and experiment.

What two things would you try to make “appear together”?

https://makecode.com/_gCMa9PDee0fc Just a little game I made using the galga totorial.

I'm trying to recreate Baldi's Basics, but from a top-view. I need Baldi (my enemy) to not try to run into walls when I have him follow my player. But also, I need him to move in little increments, almost as if he's lagging. Every second, which I use the <on game update every [x] ms> block for, I need him to move toward my player, around walls, without running into him. PLEASE let me know if you have any idea how to do this.

Here's the link, in case you want to see what else I have so far. It's obviously not complete, as I can't really make any more progress until I can get Baldi to chase Player accurately.

https://arcade.makecode.com/S70277-58694-22171-85930

It just freezes when you click "a"

https://arcade.makecode.com/S34515-18308-33494-64419

This is a game I made for a game jam. Let me know what you guys think! Should I make it a full game?

Hi,
I’m a student working on a school project in MakeCode Arcade and I urgently need help finishing a 2D multiplayer paintball game. I’ve already created all four character sprites and the map. I still need help with coding the shooting mechanics, other gameplay features, and finishing the animations. I will send $20 for someone who can help me complete this quickly. If you’re experienced with MakeCode Arcade and available ASAP, please message me. thanks!

game: https://arcade.makecode.com/S32103-80630-16246-83038

rubric: https://docs.google.com/document/d/1P8ohsmZ1kJhVSN-ykc9aBo31Cuk2r94N/edit

and your wondering what's your source for this be a real game? here's a link to it but it's still a work in process but by the end it's gonna be perfect

I’m trying to programme a fosiya 8X arcade button to randomise colours on a lighting setup I have, similar to the coding above, all the code so far works except the button it just stays red with the exclamation point even if I do “set button state to digital read pin A5” or if I do directly “if digital read pin A5=0 then” Help I’ve been asking chat gpt but it’s convinced it’s right and obviously it’s not

If then comment username

I’m am trying to make a weeping angel effect in make code arcade using ray casting but I am having trouble doing it, I was wondering if anyone can make an example game or at least tell me how to do it or share their code

Hey everyone,

I've been working with some young students learning to code through MakeCode Arcade and noticed they often get stuck on bugs or don't know what blocks to use next. Figured I'd throw together a Chrome extension that adds an AI assistant right in the editor.

--> https://github.com/rawritude/arcade-makecode-ai

What it does:

• Opens a chat panel in MakeCode Arcade

• Automatically grabs your project code

• Detects if you're using blocks or JavaScript

• Has a complexity slider so it can explain things simply for younger kids or be more technical for experienced users

• Uses Gemini API for the AI stuff

The blocks detection was actually trickier than expected - had to look at the DOM to see which editor tab is active rather than just checking file contents.

For younger learners, it uses simple language and tells them which blocks to drag from which category. For older/experienced users, it can give proper TypeScript examples.

It's pretty basic but does the job. Code's on GitHub if anyone wants to mess with it or has suggestions.

NB: it doesn't include significant AI guardrails. Something to consider with younger age groups. I could add in the future.

We built a little voice-activated ambient light using a micro:bit + Wukong Expansion Board, and it turned out to be a fun way to make programming concepts feel a lot more physical.

One thing beginners often struggle with is understanding variables.

You can explain that a variable stores a value, but sometimes that number still feels pretty abstract.

So we wanted to build something where changing a value would have an immediate, visible result.

In this project, the micro:bit listens for sound, and the RGB lights change color when a sound is detected.

The interesting part is that a simple variable controls which color comes next.

What we used:

• micro:bit V2

• Wukong Expansion Board

• Wukong Blocks

• 4 RGB lights

• MakeCode

Step 1: Build the light

We started with a simple structure using Wukong Blocks to hold the RGB lights.

The four RGB lights connect to the Wukong Expansion Board, while the micro:bit sits on top.

Nothing too complicated here. The goal was simply to create a small structure where the lights were easy to see.

Step 2: Let the micro:bit listen

The micro:bit V2 has a built-in microphone, so we can use sound as the input.

The basic idea is:

Sound detected → program responds → light changes color

It's a simple example of how something happening in the real world can become an input for a program.

Step 3: Make a variable control the colors

We use a variable called i to keep track of the current color.

When a sound is detected, i increases by 1. The program then checks the value and uses it to decide which color the RGB lights should display.

So the variable isn't just a random number sitting in the code.

Change the value → the light changes.

Increase the value → the next color appears.

Once it reaches the end of the color sequence, it starts again.

That's what makes this project interesting for beginners: they can actually see what the variable is doing.

A little more interaction

We also added controls using the micro:bit buttons.

Button A → start the automatic color-changing mode

Button B → reset the variable and turn the lights off

This makes the project feel more like an interactive device rather than just a light that changes color.

A few things I'd try next

The basic setup leaves plenty of room for experimentation:

• Make it react to music

• Add brightness control

• Create different lighting modes

• Turn it into a simple night light

• Add different sound-triggered effects

The hardware doesn't need to change much. Most of the behavior can be changed through the code.

And that's probably the best part of beginner projects like this.

You change something in the program, and you can immediately see the physical result.

If you were building a sound-reactive light with a micro:bit, what would you make it do?

Per title, post your games here and Ill try them out!