thinBasic: Basic Programming Language Community Forum - BazzBasic

BazzBasic 1.0

E.K.Virtanen — Sun, 22 Feb 2026 13:56:40 GMT

BazzBasic 1.0 released
Download Github release or source of BazzBasic: https://github.com/EkBass/BazzBasic/.../tag/BazzBasic

Feb 2026

22nd Feb. 2026

Released as version 1.0, source and binary

21st Feb. 2026

FILEREAD and FILEWRITE now supports arrays too.

Example with array:

Code:

LET FILENAME# = "array.txt"

DIM a$

a$("first") = 1

a$("second") = 2

a$("third") = 3

a$("fourth") = "Four"

a$("fourth", "temp") = "Temp"

FileWrite FILENAME#, a$

DIM b$ = FileRead(FILENAME#)

PRINT b$("fourth", "temp") ' Output: Temp

array.txt content:

Code:

first=1

second=2

third=3

fourth=Four

fourth,temp=Temp

21st Feb. 2026

Added HTTPGET and HTTPPOST. These allow you to send HTTP GET and POST requests to a specified URL and retrieve the response as a string.

Code:

DIM response$

LET response$ = HTTPGET("https://httpbin.org/get")

PRINT response$

DIM postResult$

LET postResult$ = HTTPPOST("https://httpbin.org/post", "{""key"":""value""}")

PRINT postResult$

Added LOADSHEET sprites$, , , � splits a sprite sheet image into individual sprites stored in an array.

Code:

SCREEN 640, 480, "Countdown!"

DIM sprites$

LOADSHEET sprites$, 128, 128, "examples/sheet_numbers.png"

LET x# = 256

LET y# = 176

FOR i$ = 9 TO 0 STEP -1

    CLS

    LET spriteIndex$

    LET spriteIndex$ = i$ + 1

    MOVESHAPE sprites$(spriteIndex$), x#, y#

    DRAWSHAPE sprites$(spriteIndex$)

    SLEEP 500

NEXT

END

Added FULLSCREEN TRUE/FALSE � enables or disables borderless fullscreen mode.

Code:

SCREEN 640, 480, "My title"

FULLSCREEN TRUE   ' borderless fullscreen on

FULLSCREEN FALSE  ' Windowed mode

14th Feb. 2026

Fixed INPUT and LINE INPUT when using GFX. Binary release also updated.
Added KEYDOWN() function to check the state of keyboard keys.
Added key constants for all keys I could imagine � will add more if any are found missing.

Voxel, proof-of-concept code

E.K.Virtanen — Sun, 22 Feb 2026 11:35:19 GMT

553179292-164a6aed-68f8-467c-911b-089831933812.png

3D voxel terrain with BazzBasic.

This was written with version 1.0, which I have not yet released due few things missing from manual. But Im positive I get 1.0 out in matter of hours.

https://github.com/EkBass/BazzBasic/discussions/24

Attached Images

553179292-164a6aed-68f8-467c-911b-089831933812.png (40.3 KB)

Platformer/jumping thing

E.K.Virtanen — Mon, 16 Feb 2026 16:52:50 GMT

Hi everyone.

Here is a simple platformer/jumping thing I made to see how it works with my BazzBasic interpreter.

https://github.com/EkBass/BazzBasic/discussions/23

550519086-2df7f518-6335-4ee0-8e0b-186505fb7253.png

Attached Images

550519086-2df7f518-6335-4ee0-8e0b-186505fb7253.png (14.9 KB)

Version 0.9 out

E.K.Virtanen — Fri, 13 Feb 2026 17:07:03 GMT

# BazzBasic 0.9 Released! 🎉

**BazzBasic 0.9** is now available as binary and source.

## What's New in 0.9

The latest update brings some additions aimed for game developers.

**New Math & Utility Functions:**
- `LERP(start, end, t)` � Linear interpolation between two values
- `DISTANCE()` � Calculate 2D or 3D distances with a single call
- `CLAMP(n, min, max)` � Keep values within bounds without verbose IF chains
- `BETWEEN(value, min, max)` � Quick range checking that returns TRUE/FALSE
- `EULER` � The mathematical constant *e* ≈ 2.718281828459045
- `TAU` and `QPI` � Convenient constants for 2π and π/4

**Graphics Enhancement:**
- `VSYNC(TRUE/FALSE)` � Control vertical sync for smooth rendering or uncapped frame rates

## Roadmap to 1.0

The next milestone will introduce some interesting things:

**HTTP Support** � Make GET and POST requests directly from BazzBasic. Fetch data from APIs, download files, or send data to web services.

**Sprite Sheets** � `LOADSHEET(filename, width, height)` will slice sprite sheet images into individual frames stored in an array, making 2D game animation easier.

**Under Consideration:**
- Joystick/gamepad support for game input
- Native JSON and XML parsing to and from arrays

## Get BazzBasic

- **Homepage:** https://ekbass.github.io/BazzBasic/
- **Source:** https://github.com/EkBass/BazzBasic/tree/main
- **Documentation:** https://ekbass.github.io/BazzBasic/manual/#/
- **Discussions:** https://ekbass.github.io/BazzBasic/communities.html

Ver. 0.8 out

E.K.Virtanen — Sun, 08 Feb 2026 10:52:25 GMT

Read at BazzBasic GitHub https://github.com/EkBass/BazzBasic/discussions/10

# BazzBasic version 0.8

Key issues, news and changes from 0.7

## NAudio to SDL2

This change has been done. It was actually easier to do what I expected.

Audio features works just as with version 0.7

## RAD & DEG

Added keywords **RAD** & **DEG**

## PI & HPI

**PI** returns a hard coded value of *3.141592653589793*

**HPI** returns a hard coded value of *1.5707963267948966*

These both are commonly and often used when playing with graphics. Hard coding them makes things much faster.

## Fast Trigonometry (Lookup Tables)

For graphics-intensive applications (games, raycasting, animations), BazzBasic provides fast trigonometric functions using pre-calculated lookup tables. These are significantly faster than standard `SIN`/`COS` functions but have 1-degree precision.

**Performance:** ~20x faster than `SIN(RAD(x))` for integer degree values.

**Memory:** Uses ~5.6 KB when enabled

### FastTrig()

Enables or disables fast trigonometry lookup tables.

**Parameters:**

- `TRUE` (or any non-zero value) - Creates lookup tables

- `FALSE` (or 0) - Destroys lookup tables and frees memory

### FastSin(angle)

Returns the sine of an angle (in degrees) using a lookup table.

**Parameters:**

- `angle` - Angle in degrees (automatically normalized to 0-359)

**Returns:** Sine value (-1.0 to 1.0)

**Precision:** 1 degree (sufficient for most games and graphics)

```vb

FastTrig(TRUE)

PRINT FastSin(0) ' Output: 0

PRINT FastSin(90) ' Output: 1

PRINT FastSin(180) ' Output: 0

PRINT FastSin(270) ' Output: -1

' Angles are automatically wrapped

PRINT FastSin(450) ' Same as FastSin(90) = 1

PRINT FastSin(-90) ' Same as FastSin(270) = -1

FastTrig(FALSE)

```

### FastCos(angle)

Returns the cosine of an angle (in degrees) using a lookup table.

**Parameters:**

- `angle` - Angle in degrees (automatically normalized to 0-359)

**Returns:** Cosine value (-1.0 to 1.0)

**Precision:** 1 degree (sufficient for most games and graphics)

```vb

FastTrig(TRUE)

PRINT FastCos(0) ' Output: 1

PRINT FastCos(90) ' Output: 0

PRINT FastCos(180) ' Output: -1

PRINT FastCos(270) ' Output: 0

' Use in raycasting

FOR angle$ = 0 TO 359

LET dx$ = FastCos(angle$)

LET dy$ = FastSin(angle$)

' Cast ray in direction (dx, dy)

NEXT

FastTrig(FALSE)

```

### FastRad(angle)

Converts degrees to radians using an optimized formula.

**Parameters:**

- `angle` - Angle in degrees (automatically normalized to 0-359)

**Returns:** Angle in radians

**Note:** This function doesn't require `FastTrig(TRUE)` but is included for consistency.

```vb

PRINT FastRad(90) ' Output: 1.5707963267948966 (HPI)

PRINT FastRad(180) ' Output: 3.141592653589793 (PI)

PRINT FastRad(360) ' Output: 6.283185307179586 (2*PI)

```

## Download

Source and Windows binaries https://ekbass.github.io/BazzBasic/

## Version 0.9

For version 0.9, I'm focusing on making sure that the metafiles etc. are in accordance with Windows and Avast reducing warnings when BazzBasic is run for the first time.

The easiest way would probably be to get an account in the Microsoft Store, but it costs money and I don't want to do that since it's a free open source project.

Most of the metafiles are already in order, but GitHub's own "release" method would help even more. However, I haven't had time to learn it yet.

Of course, bug hunting and fine-tuning are definitely expected with version 0.9.

*Kristian Virtanen*

*krisu.virtanen@gmail.com*

*https://ekbass.github.io/BazzBasic/*

3D maze example

E.K.Virtanen — Sat, 07 Feb 2026 13:24:04 GMT

https://github.com/EkBass/BazzBasic/discussions/9

Code:

' ============================================

' 3D RAYCASTER - Optimized Version

' BazzBasic version: https://ekbass.github.io/BazzBasic/

' ============================================





LET PI# = 3.14159265

LET PI2# = 6.28318530

LET FOV# = 1.0472

LET NUM_RAYS# = 180

LET STEP_SIZE# = 0.05

LET MAX_STEPS# = 512





LET SCREEN_W# = 640

LET SCREEN_H# = 480

LET HALF_H# = 240





' Map definition

DIM m$

DIM map$  ' Optimized map with integers

GOSUB [sub:readMap]





LET MAP_H# = 21

LET MAP_W# = 31

LET px$ = 3.5

LET py$ = 3.5

LET pAngle$ = 0





' pre-proces: change string map as integers

GOSUB [sub:convertMapToArray]





SCREEN 12

CLS





' === Main Loop ===

LET running$ = TRUE

WHILE running$

    LET key$ = INKEY

    

    LET moveSpeed$ = 0.1

    LET rotSpeed$ = 0.08

    

    IF key$ = KEY_UP# THEN

        LET nx$ = px$ + COS(pAngle$) * moveSpeed$

        LET ny$ = py$ + SIN(pAngle$) * moveSpeed$

        IF map$(INT(ny$), INT(nx$)) = 0 THEN

            px$ = nx$

            py$ = ny$

        ENDIF

    ENDIF

    

    IF key$ = KEY_DOWN# THEN

        LET nx$ = px$ - COS(pAngle$) * moveSpeed$

        LET ny$ = py$ - SIN(pAngle$) * moveSpeed$

        IF map$(INT(ny$), INT(nx$)) = 0 THEN

            px$ = nx$

            py$ = ny$

        ENDIF

    ENDIF

    

    IF key$ = KEY_LEFT# THEN

        pAngle$ = pAngle$ - rotSpeed$

        IF pAngle$ < 0 THEN pAngle$ = pAngle$ + PI2#

    ENDIF

    

    IF key$ = KEY_RIGHT# THEN

        pAngle$ = pAngle$ + rotSpeed$

        IF pAngle$ >= PI2# THEN pAngle$ = pAngle$ - PI2#

    ENDIF

    

    IF key$ = KEY_ESC# THEN running$ = FALSE

    

    SCREENLOCK ON

    

    LINE (0,0)-(SCREEN_W#, HALF_H#), RGB(50, 50, 100), BF

    LINE (0,HALF_H#)-(SCREEN_W#, SCREEN_H#), RGB(40, 40, 40), BF

    

    GOSUB [sub:RenderView]

    GOSUB [sub:DrawMinimap]

    

    SCREENLOCK OFF

    SLEEP 16

WEND





COLOR 7, 0

CLS

END





' -----------------------------------------------

' 0 = empty floor, 1 = wall

' -----------------------------------------------

[sub:convertMapToArray]

    FOR y$ = 0 TO MAP_H# - 1

        FOR x$ = 0 TO MAP_W# - 1

            IF MID(m$(y$), x$ + 1, 1) = "#" THEN

                map$(y$, x$) = 1

            ELSE

                map$(y$, x$) = 0

            ENDIF

        NEXT

    NEXT

RETURN





' -----------------------------------------------

' Render 3D view - collision check

' -----------------------------------------------

[sub:RenderView]

    LET sliceWidth$ = SCREEN_W# / NUM_RAYS#

    

    FOR ray$ = 0 TO NUM_RAYS# - 1

        LET rayRatio$ = ray$ / NUM_RAYS#

        LET rayAngle$ = pAngle$ - (FOV# / 2) + (rayRatio$ * FOV#)

        

        LET dx$ = COS(rayAngle$) * STEP_SIZE#

        LET dy$ = SIN(rayAngle$) * STEP_SIZE#

        LET rx$ = px$

        LET ry$ = py$

        LET hit$ = 0

        LET distance$ = 0

        LET steps$ = 0

        

        WHILE hit$ = 0 AND steps$ < MAX_STEPS#

            rx$ = rx$ + dx$

            ry$ = ry$ + dy$

            steps$ = steps$ + 1

            distance$ = distance$ + STEP_SIZE#

            

            LET cx$ = INT(rx$)

            LET cy$ = INT(ry$)

            

            IF cx$ >= 0 AND cx$ < MAP_W# AND cy$ >= 0 AND cy$ < MAP_H# THEN

                IF map$(cy$, cx$) = 1 THEN

                    hit$ = 1

                ENDIF

            ELSE

                hit$ = 1

            ENDIF

        WEND

        

        IF hit$ = 1 THEN

            LET angleDiff$ = rayAngle$ - pAngle$

            LET correctedDist$ = distance$ * COS(angleDiff$)

            

            LET wallHeight$ = (HALF_H# / correctedDist$) * 0.6

            IF wallHeight$ > SCREEN_H# THEN wallHeight$ = SCREEN_H#

            

            LET wallTop$ = HALF_H# - wallHeight$

            LET wallBottom$ = HALF_H# + wallHeight$

            

            LET brightness$ = 255 - (correctedDist$ * 25)

            IF brightness$ < 20 THEN brightness$ = 20

            IF brightness$ > 255 THEN brightness$ = 255

            

            LET screenX$ = INT(rayRatio$ * SCREEN_W#)

            LET screenX2$ = INT((ray$ + 1) / NUM_RAYS# * SCREEN_W#)

            LET wallColor$ = RGB(brightness$, brightness$ * 0.8, brightness$ * 0.6)

            

            LINE (screenX$, wallTop$)-(screenX2$, wallBottom$), wallColor$, BF

        ENDIF

    NEXT

RETURN





' -----------------------------------------------

' Draw mini-map 

' -----------------------------------------------

[sub:DrawMinimap]

    LET mapScale$ = 6

    LET mapOffsetX$ = 10

    LET mapOffsetY$ = 10

    

    LINE (mapOffsetX$-2, mapOffsetY$-2)-(mapOffsetX$ + MAP_W# * mapScale$ + 2, mapOffsetY$ + MAP_H# * mapScale$ + 2), RGB(0,0,0), BF

    

    FOR my$ = 0 TO MAP_H# - 1

        FOR mx$ = 0 TO MAP_W# - 1

            IF map$(my$, mx$) = 1 THEN

                LET sx$ = mapOffsetX$ + mx$ * mapScale$

                LET sy$ = mapOffsetY$ + my$ * mapScale$

                LINE (sx$, sy$)-(sx$ + mapScale$ - 1, sy$ + mapScale$ - 1), RGB(150, 150, 150), BF

            ENDIF

        NEXT

    NEXT

    

    LET plrX$ = mapOffsetX$ + INT(px$ * mapScale$)

    LET plrY$ = mapOffsetY$ + INT(py$ * mapScale$)

    CIRCLE (plrX$, plrY$), 3, RGB(255, 255, 0), 1

    

    LET dirX$ = plrX$ + INT(COS(pAngle$) * 8)

    LET dirY$ = plrY$ + INT(SIN(pAngle$) * 8)

    LINE (plrX$, plrY$)-(dirX$, dirY$), RGB(255, 255, 0)

RETURN





' -----------------------------------------------

' Read map into string array

' -----------------------------------------------

[sub:readMap]

    m$(0)   = "###############################"

    m$(1)   = "#...........#..#........#.....#"

    m$(2)   = "####..#..####..#######..#..#..#"

    m$(3)   = "#.....#........#...........#..#"

    m$(4)   = "#######..#..#..#..####..#######"

    m$(5)   = "#........#..#.....#..#........#"

    m$(6)   = "#######..#..####..#..####..####"

    m$(7)   = "#.....#..#..#.....#.....#.....#"

    m$(8)   = "####..##########..#..#######..#"

    m$(9)   = "#...........#.....#..#..#..#..#"

    m$(10)  = "####..####..#..####..#..#..#..#"

    m$(11)  = "#.....#.....#..............#..#"

    m$(12)  = "#..#######..#..#..##########..#"

    m$(13)  = "#.....#.....#..#........#..#..#"

    m$(14)  = "#######..##########..####..#..#"

    m$(15)  = "#...........#.....#..#..#.....#"

    m$(16)  = "#..##########..#######..####..#"

    m$(17)  = "#..............#..............#"

    m$(18)  = "##########..#..####..####..#..#"

    m$(19)  = "#...........#...........#..#..#"

    m$(20)  = "###############################"

RETURN

2D raycasting demo

E.K.Virtanen — Fri, 06 Feb 2026 18:00:36 GMT

Code:

' ============================================

' 2D Field-of-View (FOV) � 90-Ray Casting

' BazzBasic version: https://ekbass.github.io/BazzBasic/

' Reads walls from map array, SCREENLOCK for

' flicker-free rendering

' ============================================





LET NUM_RAYS# = 90

LET STEP_SIZE# = 0.2

LET MAX_STEPS# = 40

LET PI2# = 6.28318530





' Map definition

DIM m$

GOSUB [sub:readMap]





LET MAP_H# = 21

LET MAP_W# = 31

LET px$ = 3

LET py$ = 3





DIM vis$

CLS





' === Main Loop ===

LET running$ = TRUE

WHILE running$





    ' 1) Reset visibility

    FOR vy$ = 0 TO MAP_H# - 1

        FOR vx$ = 0 TO MAP_W# - 1

            vis$(vy$, vx$) = 0

        NEXT

    NEXT

    vis$(py$, px$) = 1





    ' 2) Cast rays � read walls from array, no screen needed

    GOSUB [sub:CastAllRays]





    ' 3) Draw everything in one go

    SCREENLOCK ON

    GOSUB [sub:DrawFOV]





    ' 4) Player

    COLOR 10, 0

    LOCATE py$ + 1, px$ + 1

    PRINT "@";





    ' 5) Status bar

    COLOR 8, 0

    LOCATE MAP_H# + 2, 1

    PRINT "Arrows=Move  ESC=Quit  Pos:"; px$; ","; py$; "   ";

    SCREENLOCK OFF





    ' 6) Wait for a keypress

    LET key$ = 0

    WHILE key$ = 0

        key$ = INKEY

        SLEEP 16

    WEND





    ' 7) Movement + collision

    LET nx$ = px$

    LET ny$ = py$

    IF key$ = KEY_UP# THEN ny$ = py$ - 1

    IF key$ = KEY_DOWN# THEN ny$ = py$ + 1

    IF key$ = KEY_LEFT# THEN nx$ = px$ - 1

    IF key$ = KEY_RIGHT# THEN nx$ = px$ + 1

    IF key$ = KEY_ESC# THEN running$ = FALSE





    IF MID(m$(ny$), nx$ + 1, 1) = "." THEN

        px$ = nx$

        py$ = ny$

    ENDIF





WEND





COLOR 7, 0

CLS

END





' -----------------------------------------------

' Cast rays � check walls from map array directly

' -----------------------------------------------

[sub:CastAllRays]

    FOR ray$ = 0 TO NUM_RAYS# - 1

        LET angle$ = (ray$ / NUM_RAYS#) * PI2#

        LET dx$ = COS(angle$) * STEP_SIZE#

        LET dy$ = SIN(angle$) * STEP_SIZE#

        LET rx$ = px$ + 0.5

        LET ry$ = py$ + 0.5

        LET hit$ = 0





        FOR s$ = 1 TO MAX_STEPS#

            IF hit$ = 0 THEN

                rx$ = rx$ + dx$

                ry$ = ry$ + dy$

                LET cx$ = INT(rx$)

                LET cy$ = INT(ry$)





                IF cx$ >= 0 AND cx$ < MAP_W# AND cy$ >= 0 AND cy$ < MAP_H# THEN

                    vis$(cy$, cx$) = 1

                    IF MID(m$(cy$), cx$ + 1, 1) = "#" THEN hit$ = 1

                ELSE

                    hit$ = 1

                ENDIF

            ENDIF

        NEXT

    NEXT

RETURN





' -----------------------------------------------

' Draw map: visible=lit, not visible=black

' -----------------------------------------------

[sub:DrawFOV]

    FOR dy$ = 0 TO MAP_H# - 1

        FOR dx$ = 0 TO MAP_W# - 1

            LOCATE dy$ + 1, dx$ + 1

            LET ch$ = MID(m$(dy$), dx$ + 1, 1)

            IF vis$(dy$, dx$) = 1 THEN

                IF ch$ = "#" THEN

                    COLOR 7, 0

                ELSE

                    COLOR 14, 0

                ENDIF

            ELSE

                COLOR 0, 0

            ENDIF

            PRINT ch$;

        NEXT

    NEXT

RETURN





' -----------------------------------------------

' Read map into array

' -----------------------------------------------

[sub:readMap]

        m$(0)         = "###############################"

        m$(1)         = "#...........#..#........#.....#"

        m$(2)         = "####..#..####..#######..#..#..#"

        m$(3)         = "#.....#........#...........#..#"

        m$(4)         = "#######..#..#..#..####..#######"

        m$(5)         = "#........#..#.....#..#........#"

        m$(6)         = "#######..#..####..#..####..####"

        m$(7)         = "#.....#..#..#.....#.....#.....#"

        m$(8)         = "####..##########..#..#######..#"

        m$(9)         = "#...........#.....#..#..#..#..#"

        m$(10)        = "####..####..#..####..#..#..#..#"

        m$(11)        = "#.....#.....#..............#..#"

        m$(12)         = "#..#######..#..#..##########..#"

        m$(13)         = "#.....#.....#..#........#..#..#"

        m$(14)         = "#######..##########..####..#..#"

        m$(15)         = "#...........#.....#..#..#.....#"

        m$(16)         = "#..##########..#######..####..#"

        m$(17)         = "#..............#..............#"

        m$(18)         = "##########..#..####..####..#..#"

        m$(19)         = "#...........#...........#..#..#"

        m$(20)         = "###############################"

RETURN