Frequently Asked Questions

BambooBasic is a modern BASIC programming language and development environment. It combines the simplicity of classic BASIC with modern features like hardware-accelerated 2D graphics (fast enough for 3D-in-2D), custom shaders, audio, networking and DirectX 12 support. Programs are transpiled to C++ and compiled to native executables.

Yes, BambooBasic is free to download and use. You can create and distribute programs commercially or non-commercially without any fees or royalties.

BambooBasic currently supports Windows (native runtime using DirectX 12). A web runtime (JavaScript/WebGPU) is in experimental development but is not recommended for production use.

You can build:

• 2D games (and 3D-in-2D games)
• Graphics applications
• Audio/music applications
• GUI applications (using the BGI windowing system)
• Utility programs
• And more!

Yes! You can freely distribute executables created with BambooBasic for commercial or non-commercial purposes.

Yes, programs compiled with BambooBasic require BambooRuntime.dll to run. You must distribute this DLL alongside your executable (.exe file).

Yes, you can create and sell commercial software with BambooBasic without paying royalties or licensing fees.

Yes, but you must post notification on the SyntaxBoom forums describing your project and how you're using the runtime. See the EULA for full details.

BambooBasic itself is proprietary software (see EULA.txt). The runtime can be freely redistributed with your programs. Programs you create are your property.

Yes, BambooBasic includes an integrated development environment with syntax highlighting, code completion, integrated building/running of programs, as well as integrated tools to help aid you in your projects development.

BambooBasic source files use the .bam extension (e.g., MyGame.bam).

BambooBasic transpiles your .bam source code to C++, then uses MinGW (g++) to compile it to a native Windows executable. This process is automatic and happens when you build your project.

Yes, the generated .cpp files are saved in your project directory. You can examine them but they are regenerated on each build.

The IDE includes debugging features similar to other BASIC language debuggers. You can also output to the output pane by using "Print", as well as the transpiled C++ files are there if you need to inspect them.

BambooBasic is a transpiler, which converts BASIC to C++, which is then handed to the g++ compiler. Even though the transpiler has error checking, some things still get through, and this is what you're seeing - g++ errors. Sometimes you can work out what has gone wrong, other times you might not figure it out. The best course of action, if you can, is try and duplicate the error with a basic example, and show me it on the SyntaxBoom forums. If not, then at least show me the error, and I can look into it, and hopefully catch it in the transpiler.

BambooBasic supports:

• 2D graphics (sprites, images, primitives, text rendering)
• A per-pixel depth buffer and quad primitive for 3D-in-2D
• Palette cycling and indexed-colour images
• DirectX 12 rendering
• Custom HLSL shaders (screen, text, and image shaders)
• Multiple render targets and canvases
• Post-processing effects

Yes — using 3D-in-2D. The 2D runtime includes a per-pixel depth buffer and a quad primitive, so you can project and render real 3D scenes with only 2D commands. Draw your faces in any order and the GPU resolves what's in front, per pixel — no manual sorting — and the same technique runs identically on every target. See the "3D in 2D" tutorial in the documentation. (The older dedicated 3D engine has been retired in favour of this unified 2D approach.)

There's no bundled physics engine — the runtime focuses on graphics, audio, input, networking and file I/O. Simple 2D physics (movement, gravity, collisions) are straightforward to write in BASIC, and there are examples to get you started.

BambooBasic supports common audio formats including .ogg, .wav, and .mp3 through the integrated SoLoud audio engine.

Yes! You can write custom HLSL shaders and apply them to screens (post-processing), text, or images. The runtime compiles shaders at runtime using D3DCompile.

BambooBasic uses BASIC-style syntax but is a distinct language. It includes modern features like custom types, methods, and object-oriented concepts that may not be present in classic BASIC.

Yes, BambooBasic supports custom types with fields and methods, including the Self keyword for instance references.

BambooBasic supports:

• Int (32-bit integer)
• Double (64-bit floating point)
• String (text)
• Custom Types (user-defined structures with fields and methods)

Yes, BambooBasic supports fixed sized arrays.

Yes, BambooBasic can interface with external DLLs and libraries through the userlib system and declaration (.decls) files.

The web runtime is under active development. Check the website and forums for updates on its status.

The native runtime uses DirectX 12 and produces Windows executables. The web runtime uses JavaScript/WebGPU and runs in browsers. The native runtime is far more stable and feature-complete.

Visit the SyntaxBoom forums. The BambooBasic section has community support, examples, and discussions. You can also join our Discord server for real-time help.

Yes, documentation is included with BambooBasic and available on the website at bamboobasic.org.

Report bugs and issues on the SyntaxBoom forums.

Yes, BambooBasic includes numerous example programs demonstrating 2D graphics, 3D-in-2D, audio, shaders, GUI systems, and more. Check the examples folder in your BambooBasic installation.

BambooBasic uses DirectX 12 for graphics rendering on Windows.

BambooBasic incorporates:

• SoLoud Audio Engine (zlib/libpng license) - Audio
• miniz (MIT license) - Compression
• wxWidgets (wxWindows Library License) - IDE

See credits.txt for complete attribution.

BambooBasic uses MinGW (g++) to compile the generated C++ code to native Windows executables.

Since BambooBasic compiles to native C++ executables, performance is excellent on that front and comparable to programs written directly in C++. The Windows DirectX12 runtime is custom made, though not as powerful as other game engines such as Unity or Unreal, it does hold its own and, testing, handles nearly 15 million triangles on a scene on my machine. Rationally, I could never achieve performance like them - they spend millions, hire specialists, liaise with GPU manufacturers, it's a no brainer.

Yes and no - BambooBasic executables are native Windows programs that only require BambooRuntime.dll (which includes all necessary dependencies). But, you may need the Microsoft Visual C++ 2015-2022 Redistributable (x64) which is available for download on the bamboobasic.org homepage under the "Download" section.

BambooBasic requires Windows 11 (DirectX 12 requirement).

Because that is now a legacy system, which will receive less and less support from device manufacturers, so it makes no sense to support it.

Common issues include:

• Poor DirectX 12 driver support on legacy integrated GPUs
• Crashes, graphical glitches, or poor performance
• Incomplete DirectX 12 feature support

For the best experience, use a dedicated GPU (NVIDIA or AMD) with up-to-date drivers. If you must use integrated graphics, ensure you have:

• The latest GPU drivers from your manufacturer
• A modern integrated GPU (Intel Iris Xe, AMD Radeon Graphics, etc.)
• Windows 11 with all updates installed

The more modern your GPU and the more up-to-date your drivers, the better BambooBasic will perform. Legacy systems with old integrated graphics may not work reliably.

Laptops with dual GPUs (integrated + dedicated) often default to the integrated GPU for power saving, which can cause crashes, glitches, or poor performance with BambooBasic.

SOLUTION - Force BambooBasic to use your dedicated GPU:

For NVIDIA GPUs:

1. Right-click on desktop and select "NVIDIA Control Panel"
2. Go to "Manage 3D Settings"
3. Under "Global Settings", change "Preferred graphics processor" to "High-performance NVIDIA processor"
4. Click "Apply"
5. Restart BambooBasic

For AMD GPUs:

1. Right-click on desktop and select "AMD Radeon Settings"
2. Go to "System" → "Switchable Graphics"
3. Set BambooBasic to use "High Performance" GPU
4. Click "Apply"
5. Restart BambooBasic

Yes! BambooBasic's BASIC-style syntax is designed to be approachable for beginners while still being powerful enough for advanced users.

Start with:

1. The included example programs (examples folder)
2. The documentation (docs folder)
3. Simple 2D graphics programs before moving on to 3D-in-2D
4. The SyntaxBoom forums for community tutorials and help

While the syntax is similar, you'll likely need to make modifications. The conversion difficulty depends on which BASIC dialect you're coming from and what features your program uses.

BambooBasic is actively developed. Check the website and forums for update announcements.

Probably not. BambooBasic is Windows-only desktop wise due to a number of factors. Adding target platforms is time consuming - the creation is okay, but supporting that further down the line, it just isn't viable for me.

Yes! Feature requests can be posted on the SyntaxBoom forums. While not all requests can be implemented, community feedback helps guide development.

It's not so much "why do we", more so, "Why do I?", and the answer to that is many BASIC game development languages have gone, or are not supported anymore, and, even though there still is quite a few, my favorites have gone, so I decided to create my own.

No, it's inspired by BlitzBasic, but not the sequel, nor spiritual sequel on the basis Mark Sibly's work was his work, and some of it was really good, and I find it a bit disrespectful if I piggy backed on his work he has done over the last two or so decades.

As easy as what you're willing to put into your games. BambooBasic lets you create games, under your own logic. You still have to put in the effort to muster everything together, you still have to "program" the game, the only thing is that the Bamboo language and runtime do the heavy lifting. If you're willing to learn, and don't expect to make the next Cyberpunk, you'll be fine.