NEWS ARTICLES


Building The New Learning Edition

PlayBASIC Devlog - Building The New Learning Edition

In this dev blog, I take you behind the scenes of the long and frustrating battle to rebuild the PlayBASIC Learning Edition (our free version).

After nearly two weeks of debugging, the old build tools decided to throw every curveball possible — from infinite loops during the build process to bizarre runtime issues that broke classic examples that have been working fine for almost 20 years.



PlayBASIC Devlog Rotating Camera System and 2D Rendering Enhancements

In this PlayBASIC development update, we explore the new rotating camera modes currently being added to the engine. These new camera systems allow developers to easily create rotating scenes, perspective-style effects, and classic 2D camera tricks without manually transforming every object.





This video demonstrates three camera modes currently in development:

• Classic 2D Camera Mode – the traditional PlayBASIC rendering system
• Rotated Camera Mode – rotate the entire scene around the viewport
• Perspective Camera Mode – a perspective-style version of the rotated camera

The demo scenes push the renderer with thousands of sprites, shapes, and primitives, all handled through PlayBASIC’s software rendering pipeline. Even on older hardware, the engine can still process surprisingly complex scenes.

Along the way we also look at the current progress on several rendering systems:

• Shape rendering (vertices, line mode, and upcoming fill support)
• Sprite and rotated sprite drawing
• Image rendering commands
• Primitive drawing (lines, boxes, circles, triangles, quads)
• Improvements to the line clipping system
• Early stress tests with large object counts

One of the main goals of this work is to make it easier for developers to build dynamic 2D scenes and retro-style effects without needing complex math or manual coordinate transformations. Previously, many of these effects required users to write their own translation and rotation systems.

Future updates will expand this further with map rendering support, improved polygon filling, and additional refinements as real-world testing begins.

This update is part of the continuing development of the next generation of PlayBASIC, which includes a major rewrite of the engine internals and compiler architecture, adding hundreds of thousands of lines of new code while maintaining the simplicity the language is known for.

If you're interested in 2D game programming, retro game engines, or learning how game engines evolve internally, follow along with the PlayBASIC devlogs.




Chapters

00:00 PlayBASIC Devlog – Rotating 2D Camera System
00:10 Classic 2D Camera Mode Explained
00:26 Rotating Camera Mode Demo (2D Scene Rotation)
00:34 Perspective Camera Mode in a 2D Engine
00:50 Creating a Tunnel Effect with 1000 Shapes
01:51 Shape Rendering in PlayBASIC
02:28 Sprite Rendering Modes (Normal vs Rotated)
03:13 Stress Test – Rendering 5000 Sprites
03:53 Vertex / Dot Rendering for Shapes
04:58 Shape Clipping and Viewport Limitations
06:00 Faster Line Clipping Algorithm
07:06 Polygon Fill Mode (Work in Progress)
07:24 Rendering Mixed Primitives and Sprites
08:13 Image Rendering Limitations in Rotated Mode
09:07 Why Built-In Camera Transforms Matter
10:27 Inside the Shape Rendering Pipeline
11:48 Future Map Rendering with Rotated Cameras
12:39 Camera Mode Commands for Developers
13:25 Rotated vs Perspective Camera Behavior
14:09 Early PlayBASIC Camera Experiments
15:33 Software Rendering Performance Test
16:05 PlayBASIC 1.65 Engine Rewrite Overview
17:42 Community IDE Development Discussion
19:29 What's Next for PlayBASIC Development
20:35 Debugging Old Engine Bugs
21:47 Writing Good Bug Reports for Engine Devs
22:28 Devlog Wrap-Up


Community

Testing and feedback from the community is incredibly valuable during development. If you're experimenting with the latest builds, share your results and help push the engine forward.

PlayBASIC Devlog Map Clipping Camera Rotation and Polygon Reduction

Hey guys,

Just checking in with a progress update on the new mapping work. This one’s been focused on something that sounds simple… but really isn’t once you dig into it:

Rotating tile maps efficiently.

On the surface the demo just looks like an image being moved around.
Hover over it though and you’ll see the truth — it’s not an image at all.

It’s a map made up of quad polygons.
In some tests that’s:

• 28,000 polygons
• 113,000 polygons
• Upwards of 450,000 potential polygons

Every tile = a filled quad.





The Problem

When there’s no rotation, clipping a tile map to the viewport is pretty straightforward.

But once you introduce:

Rotation
Scaling
Projection
Alpha blending


Now you’re transforming and submitting huge numbers of polygons that may never even appear on screen.

That’s wasted work.

The goal here is simple:

Do not rotate, scale, or render polygons we don’t need.




The New Approach

The current system uses a subdivision-style clipping method.

Instead of checking tiles individually, it:

1. Estimates which region of the map intersects the viewport
2. Subdivides that region into smaller blocks
3. Tests those blocks against the camera
4. Rejects entire sections that fall outside

It keeps subdividing until blocks reach a minimum size (currently around 4×4 tiles).
At that point, it’s cheaper to just draw them than keep testing further.

This dramatically reduces the number of polygons sent to the renderer.

Examples from the demo:

• 28,000 → ~12,000 polygons
• 113,000 → ~1,500 polygons
• 450,000 potential → drops heavily once zoomed

That’s a serious reduction.




Why This Matters

This is really about enabling:

Camera rotation on large tile maps

Without this reduction layer, rotating cameras become impractical very quickly.

The nice part is — this reduction happens before rendering.
So it doesn’t matter whether it’s:

• Software rendered
• Hardware rendered
• Future pipeline changes

The same visibility logic applies.




Other Bits & Pieces

While working on this I also:

• Split more low-level functionality into the Vector2D library
• Added point-in-quad helpers
• Used rotated quad testing for hover detection
• Tested alpha blending over outlines
• Bruteforced ridiculous polygon counts just to see what breaks

It’s very much proof-of-concept, but this version is far more stable than earlier chunk-based attempts — especially around nasty 45° rotation cases.




Where It’s Headed

Next step is integrating this into the mapping library properly.

Still need to account for:

• Tile animation
• Null / masked tiles
• Further optimization passes

But so far?

I’m actually pretty happy with how it’s behaving.

Which is rare 😄




If I can’t break it in the next round of testing, this might finally be the version that sticks.

Let me know what you think.




PlayBASIC v1.65C3 Beta 62 Released

PlayBASIC v1.65C3 Beta 62 (Release Candidate) Released – 7th Feb 2026




V1.65C3 Beta #62 is now the current build of the compiler, runtimes, and help files.

This release expands format conversion support within the DrawImage command, allowing image data to be copied between surfaces of different pixel formats. While this was possible in older editions of PlayBASIC, the system is now far more robust and reliable than ever before.

Most of the recent changes focus on the strip functions. GouraudStripV/H and TextureStripV/H have both been thoroughly reworked and tested. All four functions now properly respond to INKMODE settings, with the Texture Strip functions also gaining the ability to draw transparent strips (using mask colour) directly to the output surface.




Recent Devlogs








Pushing Software Ray Tracing In PlayBASIC



In this video, I showcase Ray Tracer Version 4 and a major leap forward in software ray tracing performance inside the legacy PlayBASIC runtime.

This demo explores how smarter data structures and batching techniques can dramatically outperform traditional brute-force ray tracing, even without GPU acceleration, threading, or native compilation. Everything you see here is running entirely in pure software on a 10-year-old laptop.

🚀 What’s New in Ray Tracer v4?

- Introduction of PBS (Potential Visibility Set) mode

- Massive reduction in ray–object intersection tests

- Scene subdivision to limit per-pixel ray checks

- Shadows handled via optimized secondary ray lists

- Smooth performance with hundreds to thousands of spheres

- Real-time experimentation with object counts and resolution

Instead of testing every ray against every object, the engine now pre-filters intersection candidates, ensuring each pixel only checks against a small, relevant subset of objects. This simple design shift results in orders-of-magnitude performance improvements.



💡 Why This Matters

- Demonstrates how algorithmic design beats brute force

- Shows what’s possible in pure CPU-based ray tracing

- Ideal for learning ray intersection testing, spatial partitioning, and optimization strategies

- Highlights PlayBASIC’s continued flexibility as a learning and experimentation platform


This isn’t a physically accurate renderer, it’s a ray intersection engine designed to explore performance limits and engine design patterns. And the results are honestly surprising!

Like, subscribe, and share if you enjoy deep-dives into PlayBASIC internals and low-level rendering techniques.

Onwards and upwards.