You can use the SANDBOX to try the ugBASIC compiler, without download anything. This tool has been designed to quickly test whether the code you are writing compiles correctly and determines the desired results.

Since the source is compiled thanks to dedicated servers, separate from the browser you are using, some commands are not available: for example, you cannot load external files or resources by using the LOAD command.

If you need to develop a program with a complete tool, we recommend installing the command line executables (see below) or UGBASIC-IDE.

To write the source code you can use a simply text editor. You can save the program in a text file and then to call the compiler, in order to convert it into an form that your Dragon 32 will be able to execute.

Otherwise you can download and use command line compilers. Here are the direct links to the compilers for the various operating systems. Select the most suitable one for your configuration:

• Linux (32 bit)
• Linux (64 bit)
• Windows (32 bit)
• Windows (64 bit)
• Microsoft Windows IDE (32 and 64 bit)

In addition to compiling with the IDE, if you are using Linux or the command line version for Microsoft Windows, you can compile the BASIC source "source.bas" into an executable file using the following command:

ugbc.d32 -o executable.bin -O bin source.bas

It is therefore possible to run everything with an emulator, such as XRoar , or to create a phisical storage, as well.

A good starting point to learn ugBASIC for the d32 platform is the examples page. The examples provide insight into the syntax and usage of many of the commands and statements available for the language.

Since ugBASIC is an isomorphic language, which does not provide abstractions, it is possible that not all examples work on all targets: those labeled d32 can be compiled to generate executable files.

If you need help and support, the best place is the official forum, where you can find answers to your questions and receive help.

ACCESSING MEMORY

• READING A BYTE
• READING A WORD
• READING A DOUBLE WORD

ARRAY MANAGEMENT

• ACCESSING (1)
• ACCESSING (2)
• ACCESSING (3)
• ACCESSING (4)
• INITIALIZING
• BOUNDS
• INIZIALIZATION

ASSEMBLY INTEGRATION

• INLINE (1 LINE)
• INLINE (MORE LINES)

BASIC COMMANDS

• SWAP NUMBERS

BIT DATATYPE

• USING DATATYPE
• BIT MANIPULATION
• BIT COMPARISON
• ARRAY OF BITS

BIT MANIPULATION

• COMBINE NIBBLES

BUFFERS MANAGEMENT

• LITERAL DEFINITION
• LOADING FROM FILE
• ALIASING ON FILE LOADING
• PRINTING ON VIDEO

CONSOLE MANAGEMENT

• MULTIPLE CONSOLE EXAMPLE

DEFINE PRAGMAS

• UNIQUE SCREEN MODE
• USING DOUBLE BUFFER
• USING DOUBLE BUFFER AND SCREEN MODE UNIQUE

DOJO PROJECT

EMBEDDED DATA

• USING DATA AND READ INSTRUCTION
• USING DATA AND READ INSTRUCTION WITH LABELS
• USING RESTORE INSTRUCTION
• USING READ END FUNCTION
• USING DATA LOAD
• USING DATA LOAD
• USING DATA AND READ INSTRUCTION WITH EXPLICIT TYPE
• USING DATA AND READ INSTRUCTION WITH LABELS
• USING RESTORE INSTRUCTION
• USING READ END FUNCTION
• USING DATA LOAD
• USING DATA LOAD
• USING DYNAMIC RESTORE

EXPANSION MANAGEMENT

EXTERNAL INTEGRATION

• CALL MACHINE LANGUAGE
• CALL MACHINE LANGUAGE WITH REGISTERS
• CALL MACHINE EXTERNAL MACHINE LANGUAGE FILE
• CALL EXTERNAL MACHINE LANGUAGE FILE
• CALL EXTERNAL MACHINE LANGUAGE FILE (USING STACK)
• ASM INLINE

FLOATING POINT

• USING COSINE FUNCTION
• THE PI CONSTANT
• USING SINE FUNCTION
• USING TANGENT FUNCTION

FLOW CONTROL

• USING AFTER..CALL
• USING AFTER..GOSUB
• USING ON GOTO
• USING ON GOSUB
• USING SELECT CASE
• USING IF..THEN..ELSE
• USING IF..THEN..ELSE IF
• USING FOR..NEXT
• USING NESTED FOR..NEXT
• USING DO..LOOP
• EXITING FROM LOOP
• EXITING FROM NESTED LOOP
• MIXED DO..LOOP AND WHILE..WEND
• MIXED DO..LOOP AND REPEAT..UNTIL
• USING EVERY..GOSUB
• USING EVERY..CALL
• USING MULTIPLE EVERY..GOSUB
• POPPING FROM GOSUB
• USING GOSUB..RETURN (1)
• USING GOSUB..RETURN (2)
• USING GOTO WITH LABELS
• USING GOTO WITH LINE NUMBERS
• WITH UNCONDITIONAL WAIT

FONT SUPPORT

• REPLACE A CHAR
• REPLACE A CHAR

GRAPHICS PRIMITIVES

• DRAWING BARS (TWO RED BARS)
• DRAWING (COLORED) BOXES
• DRAWING (PATTERNED) BOXES
• CLIPPING DRAWING
• COLORING (USING INK)
• COLORING (USING COLOR())
• DRAWING USING DRAW INSTRUCTIONS
• DRAWING LINES
• DRAWING (RANDOM) LINES
• RANDOM PLOTTING
• FILL PLOTTING
• USING GET PIXEL COLOR (POINT)
• FILL (PATTERN) PLOT
• POSITIONING (USING GR LOCATE)
• POSITIONING (USING XGR AND YGR)
• DRAWING SHAPES (USING CIRCLE AND POLYLINE)
• DRAWING RANDOM CIRCLES
• DRAWING RANDOM ELLIPSES
• DRAWING ENCLOSED CIRCLES
• TEXT COORDINATES (USING X/Y GRAPHIC)
• DRAWING AROUND TEXT
• TEXT COORDINATES (USING X/Y TEXT)
• DRAWING RANDOM TEXTS
• VERTICAL BLANK SYNC (1)
• VERTICAL BLANK SYNC (2)

I/O CONTROL

• JOYSTICK READ (BIT DECODING)
• JOYSTICK READ (FUNCTIONS)
• KEYBOARD READ (USING INKEY)
• KEYBOARD READ (USING INKEY AND ASC)
• KEYBOARD READ (USING INKEY AND SCANCODE)
• KEYBOARD READ (USING KEY STATE)
• WAIT FOR A KEY
• KEYBOARD READ (USING INPUT$)

IMAGE BLITTING

• BASIC MASKING

MATHEMATIC ROUTINES

• ABSOLUTE VALUE (USING ABS)
• CALCULATE DISTANCE
• SUM OPERANDS (USING +)
• POWER AND MULTIPLICATIVE OPERANDS (USING ^ AND *)
• ASSOCIATIVE PRIORITY (SUMS AND PRODUCTS)
• ASSOCIATIVE PRIORITY (ALL OPERATIONS)
• USING RELATIVE NUMBERS
• HEXADECIMAL REPRESENTATION
• DECIMAL TO HEXADECIMAL
• SOME SIGNED OPERATIONS
• CONVERTING TO INTEGER
• FAST OPERATIONS (USING INC/DEC)
• FAST OPERATIONS (USING ADD)
• WITH FAST OPERATIONS (USING MUL)
• FAST OPERATIONS (USING DIV)
• RANDOM VALUES (USING RND())
• WITH NOT REPETITIVE RANDOM VALUES
• MAXIMUM VALUE (USING MAX)
• MINIMUM VALUE (USING MIN)
• LIMITS OF NUMERIC TYPES
• CHECKING SIGN / UNSIGN CONVERSION
• SIGN (USING SGN())
• INTEGER SQUARE ROOT (USING SQR())

MULTI TASKING

• SIMPLE CONCURRENCY (2 TASKS)
• CONDITIONATED CONCURRENCY (WAIT FOR ENDING TASK)
• ACCESSING VARIABLES (EXPLICIT)
• ACCESSING VARIABLES (IMPLICIT)
• PRE-EMPTIVE PARALLEL COMPUTING
• MULTITHREADED ANIMATION (1)
• MULTITHREADED ANIMATION (2)

OTHER CONTRIBUTIONS

• PRINTABLE CHARACTERS
• PRINTABLE CHARACTERS (COMPRESSED)
• ASSEMBLY FOR BEGINNERS (MOTOROLA 6809)
• TIME CALIBRATION
• 3D ROTATING CUBE
• 3D ROTATING CUBE (2)
• 3D ROTATING CUBE 10 lines
• FIBONACCI CALCULATION
• FOR...NEXT BEST PRACTICE
• FOR...NEXT BEST PRACTICE
• IF SPEED TEST
• MEMORY SCANNER
• MEMORY SCANNER 10 lines
• MINIGAME
• NABOO N1 STARFIGHTER
• NABOO N1 STARFIGHTER (SCALED)
• PARABOLA AND HYPERBOLA
• PRIME NUMBERS
• PRIME NUMBERS (2)
• PRIME NUMBERS (3)
• PRIME NUMBERS (4)
• RANDOM DISTRIBUTION
• SHUFFLING
• SIERPINSKI CHALLENGE (optimized)
• SIERPINSKI CHALLENGE (final)
• DRAWING SPOCK
• DRAWING SPOCK USING DATA
• THE MILL
• A CARTOON FOREST
• TIMERS!

SCREEN MANIPULATION

• CLEARING SCREEN (USING CLS) (1)
• CLEARING SCREEN (USING CLS) (2)
• CHANGING MODE
• CHANGING RESOLUTION
• CHECK RESOLUTION
• BEST RESOLUTION (BITMAP MODE)
• BEST RESOLUTION (TILEMAP MODE)

SPRITE MANAGEMENT

STATIC IMAGES

• MONOCHROME IMAGE CAPURE (USING GET IMAGE)
• MULTICOLOR IMAGE CAPURE (USING GET IMAGE)
• IMAGE CAPURE (USING GET IMAGE AND PALETTE)
• LOADING IMAGE ( USING PRINT )
• LOADING MULTICOLOR IMAGE ( USING PRINT )
• DISPLAY MONOCHROME IMAGE
• DISPLAY MUILTICOLOR IMAGE
• LOAD AND DISPLAY ONE FRAME IMAGE
• DISPLAY ANIMATIONS
• DISPLAY MONOCHROME IMAGE (USING PUT IMAGE)
• DISPLAY MULTICOLOR IMAGE (USING PUT IMAGE)
• DISPLAY A RED TOKEN (USING PUT IMAGE)
• LOADING FLIPPED IMAGE (USING FLIP X)
• SEQUENCE LOADING AND DISPLAY OF A FRAME

STORAGE MANAGEMENT

STRING MANIPULATION

• ASCII VALUE (USING ASC())
• LETTER CASING (USING UPPER/LOWER)
• GENERATE CHARACTER (USING CHR())
• FLIPPING STRINGS
• SEARCH INSIDE A STRING (USING INSTR())
• SEARCH INSIDE A STRING FROM A POSITION (USING INSTR())
• EXTRACT A SUBSTRING (USING LEFT())
• REPLACING A SUBSTRING (USING LEFT())
• MEASURE THE LENGHT OF A STRING (USING LEN())
• EXTRACT / REPLACE A SUBSTRING (USING MID())
• EXTRACT A SUBSTRING (USING RIGHT())
• REPLACE A SUBSTRING (USING RIGHT())
• GENERATE SPACES (USING SPACE())
• CONVERT NUMBERS (USING STR())
• GENERATE STRINGS (USING STRING())
• SUBTRACTING STRINGS
• CONVERTING A STRING TO NUMBER (USING VAL())

TEXTS OUTPUT

• HORIZONTAL SCROLLING (USING HSCROLL)
• VERTICAL SCROLL (USING VSCROLL)
• ERASING TEXT (USING CLINE)
• USING ESCAPE SEQUENCES (1)
• USING ESCAPE SEQUENCES (2)
• TEXT POSITIONING (USING LOCATE)
• TEXT POSITIONING (USING HOME)
• TEXT POSITIONING (USING CMOVE)
• TEXT POSITIONING (USING CMOVE$())
• TEXT POSITIONING (USING AT$())
• TEXT POSITIONING (USING AT$()/LOCATE)
• TEXT POSITIONING (USING LOCATE/CMOVE)
• TEXT POSITIONING (USING TAB$())
• TEXT POSITIONING (USING CDOWN)
• TEXT POSITIONING (USING CDOWN$())
• TEXT POSITIONING (USING SPC())
• HELLO WORLD
• PRINTABLE CHARS
• PRINT (WITH OPERATORS)
• GET TEXT POSITION (USING XCURS()/YCURS())
• GET TEXT POSITION (USING MEMORIZE/REMEMBER)

TILESET SUPPORT

• BASIC USAGE
• TILE PROPERTIES
• BASIC TILEMAP LOADING (1)
• BASIC TILEMAP LOADING (2)
• SCROLLING TILEMAP
• USING MULTILAYERS TILEMAP
• USING TILEMAP
• RETRIEVING A TILE (MULTILAYER)

TSB PROJECT

• AT STRINGS
• BLOCK / REC COMMANDS
• DEFINE CENTER AND NEW LINES
• USING CGOTO
• ALTERNATIVE SYNTAX FOR CIRCLE
• USING D!PEEK AND D!POKE
• USING DUP
• USING FILL
• USING INSERT FUNCTION
• USING INSERT
• USING INST
• USING JOYSTICK
• USING LOOP WITH SIMONS' BASIC SYNTAX
• USING MULTI
• DOUBLE DOLLAR
• USING DOUBLE PERCENT
• USING OPTION CALL PRAGMA
• USING PAUSE
• USING PLACE

USER-DEFINED PROCEDURES

• USING GLOBAL VARIABLES
• ALL VARIABLES AS GLOBAL (USING WILDCARD *)
• DEFINING A PROCEDURE (BUT NOT CALLING IT)
• CALL A PROCEDURE (USING [])
• CALL A PROCEDURE (ALL WAYS)
• CALL A PROCEDURE (USING ON...PROC)
• EXITING FROM A PROCEDURE
• USING LOCAL VARIABLES (1)
• USING LOCAL VARIABLES (2)
• RETURN VALUE (USING PARAM$())
• RETURN VALUE (USING RETURN) (1)
• RETURN VALUE (USING RETURN) (2)
• RETURN VALUE (USING RETURN) (3)
• CALL WITH SINGLE PARAMETER
• CALL WITH MULTIPLE PARAMETERS
• USING SHARED VARIABLES

VIDEOGAME ISPIRED

• BLADE RUNNER OPENING

The ugBASIC compiler supports NTSC (working frequency: 60 Hz) version, and automatically detects the working frequency to calibrate the delays. In particular, it defines two constants with the same name, and initializes the constant TICKS PER SECOND.

This is the value of the various constants in the various versions:

The ugBASIC language supports up to 2 joysticks, using the JOY(n) statement, and the keyboard. The left joystick is in port 0, while right joystick in port 1.