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 Thomson TO8 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.to8 -o executable.k7 -O k7 source.bas

It is therefore possible to run everything with an emulator, such as DCMOTO using the following command:

LOADM"CASS:",,R

or to create a phisical storage, as well.

A good starting point to learn ugBASIC for the to8 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 to8 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

ANIMATION SUPPORT

• A RUNNING BOY
• A MOVING BOY

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

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

FLOATING POINT

FLOW CONTROL

FONT SUPPORT

• REPLACE A CHAR
• REPLACE A CHAR

GRAPHICS PRIMITIVES

I/O CONTROL

IMAGE BLITTING

MATHEMATIC ROUTINES

• LIMITS OF NUMERIC TYPES
• CHECKING SIGN / UNSIGN CONVERSION

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)
• FIBONACCI CALCULATION
• FOR...NEXT BEST PRACTICE
• FOR...NEXT BEST PRACTICE
• GET/PUT PERFORMANCE
• IF SPEED TEST
• 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 (final)
• DRAWING SPOCK
• DRAWING SPOCK USING DATA
• STAFIELD
• TEST CARD
• THE MILL
• A CARTOON FOREST
• TIMERS!

SCREEN MANIPULATION

• CLEARING SCREEN (USING CLS) (1)
• CLEARING SCREEN (USING CLS) (2)

SPRITE MANAGEMENT

STATIC IMAGES

• 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

• HELLO WORLD
• PRINTABLE CHARS
• PRINT (WITH OPERATORS)

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)

TRAVELLING PATHS

• LINEAR PATHS

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

The ugBASIC compiler supports both the Thomson TO8 PAL (working frequency: 50 Hz) and NTSC (working frequency: 60 Hz) versions, 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 only the keyboard.