BAS File

What are BAS files and how to open them

Are you having problems opening a BAS file or are you simply curious about its contents? We're here to explain the properties of these files and provide you with software that can open or handle your BAS files.

What is a BAS file?

BAS files have multiple uses, and BASIC Source Code is one of them. Read more about the other uses further down the page.

BASIC Source Code

BASIC is a programming language that was created in the 1960s and the name is an acronym for Beginner's All-Purpose Symbolic Instruction Code. When a program source code file is created using the BASIC language, it is saved with the .bas file extension.

There are many variants of the BASIC language made for different computers and operating systems. This page lists most of them.

How to open BAS files

Important: Different programs may use files with the BAS file extension for different purposes, so unless you are sure which format your BAS file is, you may need to try a few different programs.

While we have not verified the apps ourselves yet, our users have suggested ten different BAS openers which you will find listed below.

Last updated: August 23, 2026

All known file formats using extension .BAS

While BASIC Source Code is a popular type of BAS-file, we know of 23 different uses of the .BAS file extension. Different software may use files with the same extension for different types of data.

AmigaBASIC Source Code

AmigaBASIC Source Code is the file format used by AmigaBASIC to store BASIC programs in machine-readable form saved in binary or protected mode. The format keeps the program already tokenized so keywords and variable names are encoded with compact binary tokens instead of plain text, which saves space and speeds up loading. It is produced by the AmigaBASIC interpreter included with AmigaOS versions 1.1 to 1.3. These files can later be loaded, listed, run, or converted to ASCII text source if needed. Programs saved in protected form are encrypted so they cannot be listed or modified.

AmigaBASIC's SAVE command supports several modes: ASCII mode writes the program as readable text; binary mode (normal) writes the tokenized form so that keywords and variables are encoded; protected mode makes a binary file that cannot be reverted to tokenized or ASCII form. The binary form includes compact line encoding ending with specific terminators, plus a variable/label name table appended at the end. Tools like "ab2ascii" can convert binary AmigaBASIC files into readable ASCII listings.

The format begins with a two-byte header indicating the file type: the byte 0xF5 marks a normal binary saved file; 0xF4 followed by 0xC2 signals a protected program. ASCII-mode saves have no such header. Each program line in binary is stored as a length byte, followed by the line's content in tokenized form, ending the file with terminator bytes.

Amstrad CPC Locomotive BASIC Source Code

Amstrad CPC Locomotive BASIC Source Code files contain programs written in the Locomotive BASIC dialect used on Amstrad CPC and CPC+ computers. Such programs are stored in a fully tokenised, binary format so that reserved words, keywords and other BASIC constructs are compacted for faster loading and execution. They are created by the Locomotive BASIC interpreter built into the ROM of these machines when the user inputs code and chooses to SAVE without specifying the ASCII ("A") option. These files are generally loaded and run by the same interpreter, which can also convert them back to human-readable form using the LIST command.

The format represents each BASIC program line in memory using a fixed structure: a 16-bit little-endian length count that includes itself, a 16-bit little-endian line number, then the tokenised line content, ending with a zero byte marking the end of that line. A length value of zero marks the end of the program. Keywords are encoded as single or double byte tokens; variables, integers, strings and floating-point numbers have specific token codes (e.g. the &1f token for floating-point numbers followed by five bytes). String variables are prefixed with particular tokens and use bit-7 flagging on their last character to identify end-of-name. RSX commands (resident system extensions) are entered with a pipe ("|") prefix and encoded using a special token sequence that includes the RSX name with its last character having bit-7 set. Version 1.0 and 1.1 of Locomotive BASIC differ in the keywords and RSXs available (for example version 1.1 adds COPYCHR$, DEC$, FRAME etc.).

Files in this format can often be recognised by specific byte-level signatures: there is a 0x00 byte at offset 0; the ASCII characters "BAS" appear at offset 9; another 0x00 occurs at offset 18; and two zero bytes (0x0000) show up at offset 26.

Atari GFA-BASIC Source Code

Atari GFA-BASIC Source Code files contain tokenized source code for the GFA-BASIC interpreter on Atari ST computers. They store GFA-BASIC program text in a compressed binary form so that keywords and syntax are replaced by tokens, making the file load quickly and take less disk space. This format is used when saving a program in GFA-BASIC versions 1.00 through 2.02 under Atari ST; earlier or later versions may use different tokenization or file extensions. Research shows this binary tokenized source is what GFA-BASIC expects when loading source code with the LOAD command rather than merging ASCII listings.

These files are written by the GFA-BASIC editor/interpreter when a program is saved in its native tokenized form. When loaded by GFA-BASIC, the interpreter can immediately execute or compile the code without needing to re-tokenize keywords or syntax, which speeds up startup and conserves memory. For editing or inspection by humans, versions saved in ASCII form (using commands such as SAVE,A or MERGE) produce human-readable text rather than this binary tokenized format.

The format is identified by a byte signature at its start: at offset 0 the bytes "00 01 47 66 41 42 41 53 49 43" (ASCII "..GfABASIC") mark a tokenized GFA-BASIC file in the v1.00-2.02 range.

B4X BASIC Source Code

B4X BASIC Source Code files store program modules written for the B4X suite of tools. Anywhere Software's B4X provides a single BASIC-like programming language and IDE used to build applications and libraries for platforms such as Android (B4A), iOS (B4i), desktop and server via Java/JavaFX (B4J), and microcontrollers (B4R). Source code in this format defines routines, classes, global variables, and designer metadata used together in B4X projects.

A file of this type is text-based, editable in the B4X IDE. It represents one module - either the main module or an additional module - in a B4X project. The content may include subs (procedures or functions), class modules with Initialize, Class_Globals sections, global variables (Globals or Process_Globals), event handlers, conditional compilation directives, and designer attributes. Main modules are usually stored in files with a ".b4a", ".b4i", etc., extension, while additional modules (tabs) are stored with this format.

Text encoding often begins with a UTF-8 Byte Order Mark (EF BB BF). Files include markers such as ModulesStructureVersion, @EndOfDesignText@, SS_GLOBALS (or Sub Globals or Class_Globals), TYPE definitions, and lexical structures like End Sub. These keywords help the IDE parse, load the module in the visual designer, and distinguish code sections from design metadata.

BAS VBDOS Pro Source Code

We know that one BAS format is BAS VBDOS Pro Source Code. We have not yet analyzed in detail what these files contain and what they are used for. We're working on it.

Cambridge Z88 BASIC Source Code

The format called Cambridge Z88 BASIC Source Code is the tokenised form of BASIC programs used by the Cambridge Z88's built-in BBC BASIC interpreter in its OZ operating system. It stores programs in a compact, binary representation rather than plain text, so that keywords, line numbers and other BASIC syntax are encoded internally for faster loading and reduced space usage.

These files are written by the Z88's BASIC language saving routines (via the Filer or BASIC "SAVE" command). They are loaded and executed back into BBC BASIC on the Z88, not edited as text directly because of their tokenised structure. For editing, a program can be LISTed to a plain text file or transferred via the CLI in un-tokenised form; once edited, it must be converted back (or entered via BASIC) to run.

Internally the format begins with a byte signature that TRiD identifies as matching Cambridge Z88 BASIC Source Code: one example is the presence of the two-byte sequence 0x0A00 at offset 1, and it contains the text string "*NAME" somewhere in the file. These markers help distinguish it from plain text BASIC listings or tokenised forms from other systems.

Canon Hack Development Kit UBASIC Script

Canon Hack Development Kit UBASIC Script files are small automation programs written for Canon cameras that run the CHDK firmware. They let users automate camera actions such as taking pictures, changing settings, or using the intervalometer without physically pressing buttons. UBASIC scripting is part of CHDK's support for simple in-camera programming using a modified BASIC dialect.

These scripts are created by photographers or hobbyists using a text editor. Once written, they are saved into the CHDK/SCRIPTS folder of an SD card inserted in a supported Canon camera. The firmware loads and executes them upon request. Scripts can include headers that set their title and parameters (for example, "@title" and "@param" fields to allow configuration via the camera's script menu) and body sections containing commands like shoot, sleep, loops (for…next), conditional statements (if…then), label-based subroutines (gosub), and button emulation (click, press, release).

Scripts are limited in size and complexity: for example, there is an 8 KB maximum script size, loops can nest only up to four levels deep, and a maximum of ten nested gosub calls. If the syntax is incorrect during loading or execution, CHDK reports an error with the line number.

Some scripts begin with a script-header section marked by special keywords. A script header may contain a line starting with "@title" to name the script, lines with "@param" to define variables that the user can set via the camera UI, and "@default" to set default values of those parameters. Commands throughout the rest of the script include print (to display text on the viewfinder or LCD), shoot (to trigger the camera shutter including autofocus and exposure), sleep (pause execution), and commands to simulate pressing buttons like "click \"button_name\"" or "press \"button_name\"".

A technical identifier of this format is that scripts often start with the ASCII sequence "@title" at the very beginning of the file, and they contain key substrings such as "SHOOT", "TITLE", or "PRINT" among their text.

GW-BASIC Protected Source Code

GW-BASIC Protected Source Code is a version of GW-BASIC program files saved in an encoded binary form that prevents viewing or editing of the source. It is produced by Microsoft GW-BASIC (or compatible versions, including BASICA) using the SAVE command with the P option (SAVE "name",P). This mode stores a tokenized version of the program and then applies an encoding step so that operations like LIST or EDIT fail when the file is loaded.

In protected source code format, the first byte of the file is changed to a signature byte (0xFE) to distinguish it from unprotected tokenized files (which use 0xFF). After that, all remaining bytes are encoded using a pseudo-encryption process involving exclusive-or operations with two fixed key sequences embedded within the GW-BASIC interpreter. On LOAD, the interpreter decodes the data so the program can run, but retains a protection flag preventing listing, editing, chaining with MERGE, or use of PEEK, POKE, BSAVE, BLOAD, and similar commands on the protected program.

The encoding uses two key arrays: Key1 is 13 bytes long, Key2 is 11 bytes long. Two counters (one for each key) start at the lengths of their respective keys and are decremented with each processed byte; when a counter reaches zero it wraps back to its initial value. To decode, for each byte (starting from the second byte of the file), subtract the current value of the Key2-counter, then exclusive-or with the corresponding bytes from both keys, then add the current value of the Key1-counter. Encoding reverses that: subtracting Key1-counter, xor with both keys, adding Key2-counter.

Byte-level signatures: the very first byte is 0xFE at offset 0. When decoded, at offset 2 one of the key-derived values will result in 0xA9; at offset 4 a derived 0x54 appears (per observed protected files). These signature patterns help automated tools (like TRiD) distinguish this protected GW-BASIC format.

HBasic Source Code

HBasic Source Code files are plain-text program source files written in the HBasic programming language, produced and edited with the HBasic integrated development environment. They hold the human-readable BASIC-style code that defines logic, functions, variables, control structures, forms, classes, and other elements that make up an HBasic application. HBasic supports object-oriented features and components built in C++ (shared libraries) or defined directly in its own class syntax.

These files are created when writing or saving modules, scripts, or programs inside the HBasic IDE. Once authored, they are loaded into the interpreter for debugging, execution, or compiling/linking with C++ components in shared libraries (packages). The workflow usually involves authoring source code, referencing external components or libraries, using forms for UI or data management, and finally running or distributing the resulting program.

These files begin with the ASCII bytes "HBASd." at offset zero, which distinguishes it from other BASIC-style source files.

IS-BASIC Source Code

IS-BASIC Source Code files store programs written in the IS-BASIC dialect for the Enterprise home computer. The Enterprise is a Z80-based microcomputer produced by Intelligent Software in the mid-1980s. IS-BASIC is provided as a 16 KB ROM cartridge, not built into the machine's internal ROM, and adheres to the ANSI BASIC standard with structured constructs such as multi-line IF…THEN…ELSE, DO…LOOP with WHILE/UNTIL, SELECT…CASE, local variables, procedures and functions.

Programs written in IS BASIC are stored in a tokenised binary form rather than plain text. Basic keywords, control structures, and other reserved words are replaced by single-byte tokens to conserve memory and speed up parsing at runtime. They are loaded and executed by the IS-BASIC interpreter from storage (typically tape, cartridge, or disk), and may be edited via the built-in screen editor provided in the EXOS operating system before being run.

Files of this format are identified by specific internal byte signatures. For example, one common signature includes the bytes 0x0004 at offset 0, a run of null (zero) bytes at offset 5, and the two ASCII characters '.' followed by '' ('..') at offset 18. These signatures help distinguish IS-BASIC source from other BASIC dialects that also use the same file extension.

Mallard BASIC Source Code

Mallard BASIC is a BASIC interpreter for CP/M produced by Locomotive Software. It was made for Amstrad PCW, ZX Spectrum, and Zilog Z80.

Memotech MTX BASIC Source Code

What kind of file this is Memotech MTX BASIC Source Code files hold programs written for the MTX line of home computers made by Memotech. These files contain source code written in the MTX version of the BASIC language, possibly including inline machine code using the built-in assembler ("CODE" or "ASSEM" lines). They are used for authoring, saving, and later loading or running BASIC programs under the MTX BASIC interpreter.

How it is produced and used The MTX BASIC interpreter ROM on systems such as the MTX-500 or MTX-512 provides commands to enter and edit BASIC lines, and also supports inserting machine code lines via the assembler. When a user saves a BASIC program (including any assembler code embedded as CODE/ASSEM lines) it is stored in source code format. Such .BAS files can later be loaded back into BASIC via commands like LOAD or USER LOAD under disk systems, or via cassette, so the user can continue editing or run the program.

Files in this format have a distinctive magic signature: at offset 0 they begin with the four bytes F2 F8 59 02 (in hexadecimal).

Microsoft QuickBASIC Source Code

Microsoft QuickBASIC Source Code files store the human-readable instructions that a programmer writes in the QuickBASIC development system. These files arise when using Microsoft QuickBASIC to write BASIC programs: one writes code in its built-in editor or a compatible ASCII text editor, and the file preserves the program statements, comments, labels, declarations, data definitions, functions and subroutines exactly as entered. The source code is later compiled or run by the QuickBASIC environment to build executable programs or for testing.

These source files may exist in different internal forms depending on how QuickBASIC was instructed to save them. In "Text" form the file's contents are plain ASCII text and editable in any text editor. In "Compressed" form the file is a binary tokenized version where QuickBASIC replaces keywords and symbols with internal tokens so loading and parsing happen faster; the Compressed variant still permits editing when loaded into QuickBASIC. "Protected" files are saved so that the human-readable source cannot be viewed or further modified, and such files cannot be compiled outside the QuickBASIC environment.

QuickBASIC enforces limits on the source code layout. A single logical line may be up to 256 characters long when entered in the built-in editor; if an underscore is used to continue a line (outside DATA or REM statements), multiple physical lines combine into one at load time so that limit can be exceeded. Variables have type-declaration suffixes like %, &, !, #, or $, user‐defined types are declared with TYPE and END TYPE; comments begin with REM or a single apostrophe. Labels can be numeric (0 through 65529) or alphanumeric (1 to 40 characters beginning with a letter and ending with a colon), and statements can be joined on one line using colons.

In the binary (Compressed or Protected) variants, the file begins with a distinguishing byte known as the magic byte; for example, tokenized source files start with 0xFF while protected files begin with 0xFE. The remainder of the file encodes QuickBASIC's internal token representation of keywords, symbol tables, and source lines rather than plain text.

MSX BASIC Source Code

MSX BASIC Source Code files are tokenized program files created by MSX BASIC, the built-in BASIC interpreter on MSX home computers. These files store BASIC program listings in a compact form so that they take less space in memory and load more quickly when run directly from MSX BASIC. The tokenized form also allows the interpreter to skip having to re-tokenize ASCII text at runtime. Such files are produced by commands like SAVE (to disk) or CSAVE (to cassette) when using the tokenized option. They can be loaded back into MSX BASIC using LOAD (for disks) or CSAVE-compatible routines (for tape devices).

MSX BASIC can also save programs as plain ASCII text, which allows them to be edited in a standard text editor or transferred between systems, but those are not in this format. The tokenized version begins with a header byte of value 255 (0xFF) to indicate the start of a serialized BASIC token file. After that, the file contains a dump of program memory structure: memory addresses of program lines, line numbers, tokenized statements and functions, encoded numeric literals in BCD format, and an end-of-program marker of two zero bytes.

The format is identified by having 0xFF at offset 0 and 0x80 at offset 2. These specific byte signatures help distinguish the MSX BASIC tokenized source format from other formats using the same extension.

PyBasic Source Code

PyBasic source code files store programs written for the PyBasic interpreter, a simple interactive BASIC interpreter implemented in Python by richpl. These files preserve all program statements, line numbers, variables, DIM declarations, string and numeric literals, and the internal lexical tokens that PyBasic uses to understand and run the code.

PyBasic itself creates these files when the SAVE command is used inside the interpreter. When the interpreter loads one of these files via LOAD, it restores the entire state of the BASIC program: its lines, tokenized internal form, and ready-to-run structure. In practice, code examples in the PyBasic repository - like factorial.bas, adventure.bas, life.bas - are stored in this format.

Internally, PyBasic source files use Python's pickle module to serialize the in-memory representation of the program, not plain editable text. That means although the program can run through SAVE and LOAD, editing outside the interpreter isn't straightforward without first exporting or reconstructing the source code via LIST commands.

A technical signature for this format includes several internal markers: bytes starting with 0x80037D7100 at offset 0, and strings such as (CBASICTOKEN, CATEGORYQ, COLUMNQ, LEXEMEQ embedded in the file. These are part of PyBasic's internal serialized token set and help diagnostic tools recognize the format.

QuickBASIC Extended Source Code

QuickBASIC Extended Source Code is the format used by Microsoft QuickBASIC Extended version 7.1, also known as the Microsoft BASIC Professional Development System 7.1, for storing source programs. It holds human-readable code written in the Extended BASIC dialect, including declarations, statements, modules, functions, user-defined types, library references, and other constructs supported by QuickBASIC Extended. These files are generated during software development with QBX and are edited, compiled, or linked to produce executables.

Files in this format are created by the QuickBASIC Extended compiler/editor in Microsoft BASIC PDS 7.1 and serve as the textual source for BASIC programs that QBX or BC compile. They typically precede compilation and are included among project files or library source distributions. The source text allows programmers to maintain and change programs; after editing, the compiler processes these files into object code and final executables.

Internally the format is text with special tokens or structure specific to QBX, but it begins with a recognizable binary signature, not a plain-text script. The first byte is 0xFC at offset 0, followed by 0x01000D00 at offset 2, then 0x01 at offset 7. Additional signature bytes include 0x01070001020304060508 at offset 9, 0xFFFF2400 at offset 21 (ASCII for "..$"), 0x0000 at offset 109, and 0x5200 at offset 113. These byte signatures distinguish this format from other BASIC-derived or tokenized source types.

Robotron HC/KC Serie BASIC Source

Robotron HC/KC Serie BASIC Source files are plain-text program listings written in the BASIC dialect used on Robotron HC-900 / KC-85-2 / KC-85-3 / KC-85-4 microcomputers. They store the source code of BASIC programs that run under the built-in or packaged BASIC interpreter (for example for graphics, sound, input/output) supplied with those systems. These listings are typically created when users type programs into the system's BASIC prompt and then save the code to external storage (cassette, disk, or module), or by typing into editors and transferring.

These source files are written using the syntax and reserved words of HC-BASIC or KC-BASIC, depending on the model. They include BASIC statements like LET, GOTO, DATA, PRINT, and graphics or sound commands when the hardware supports them. On HC-900 (KC-85-2), BASIC usually must be loaded from cassette or module if not in ROM, while later KC-85 models have BASIC in ROM. The saved source code is loaded via system commands (for example CLOAD) and then RUN under the BASIC interpreter. These files allow programmers to edit, share and re-execute BASIC programs rather than distributing only compiled or binary forms.

Internally, such files may begin with a fixed signature to identify them. One known signature is the sequence of bytes represented as ".B:" followed by two null bytes (ASCII for ".B:\0\0") at the very start of the file.

STOS BASIC Source Code

STOS BASIC is a dialect of the BASIC programming language for the Atari ST personal computer.

TRS-80 Level II BASIC Source Code

TRS-80 Level II BASIC Source Code files hold BASIC programs for the TRS-80 Model I and Model III machines using the Level II (Microsoft-derived) BASIC interpreter. They store tokenized BASIC source lines so that commands like PRINT, IF, GOTO and others are reduced to single-byte tokens rather than spelled out in ASCII. Such files are created when a BASIC program is saved from Level II BASIC in memory (RAM) to tape or disk, so that key reserved words are compacted for faster loading and smaller storage.

Loading routines in the TRS-80 BASIC interpreter expect these program files in tokenized form rather than plain ASCII: line numbers, pointers, and tokens must follow the internal program memory layout that the interpreter uses. These files are used by BASIC to LIST, RUN, SAVE, LOAD, and MERGE programs. Plain text (non-tokenized) BASIC listings are sometimes used for printing or manual editing, but they are different from this format.

Visual Basic Source Code

Visual Basic Source Code files store modules of code written for Microsoft's classic Visual Basic (including VB6) or for Visual Basic for Applications (VBA). These modules contain procedures (Subs and Functions), declarations of variables, constants, user-defined types, and external procedure or DLL references. A standard module is code-only: it does not define forms or user interfaces, but defines code that can be called from anywhere in the application or from other modules. This format allows developers to organise shared logic, global routines, and utility functions separately from forms and classes.

Such a module is created by the Visual Basic IDE (or the VBA editor) when adding a "Standard Module" to a project. Once created, code is written by the developer using plain-text syntax: public/private declarations, Option statements, Sub / Function blocks, Type definitions, and other constructs. During development these files are edited, saved, and compiled by Visual Basic. When the project is built, code in these modules is combined with form and class modules to produce an executable, DLL or application script, depending on whether it is VB6, VBA, or a similar environment.

Files in this format are plain text with no fixed binary signature. In VB6 or VBA, exported standard modules begin with a line such as   Attribute VB_Name = "ModuleName" followed by the code blocks (Subs, Functions, etc.). Declarations section may include Public, Private, or Dim statements for variables, constants, and user-defined Types; then procedural code with Sub / Function / End Sub / End Function blocks. There is no magic byte header, distinguishing them by content rather than by fixed signature.

ZBasic Source Code

ZBasic is a compiler developed by Simutek in 1980. It is available for MS-DOS, Apple II, Macintosh, CP/M, and TRS-80 computers.

ZX Spectrum +3 BASIC Source Code

ZX Spectrum +3 BASIC Source Code files store programs or data created using the Sinclair ZX Spectrum +3's built-in BASIC under its +3DOS disk operating system. These files result from the BASIC SAVE command or from operations that generate BASIC programs, numeric or character arrays, or machine code meant to be loaded or run by the +3.

When BASIC on the +3 writes a source code file, it often includes a special header called a +3DOS header at the start of the file. This header lets the system know the file type (program, numeric array, character array, or code), how large the file is, and where in memory or which line to start execution when the file is loaded. It also stores BASIC-specific metadata such as the auto-start line for BASIC programs.

The +3DOS header is 128 bytes long. At offset 0 the ASCII signature PLUS3DOS appears, followed by a soft-EOF marker (byte value 26 at offset 8), then issue and version numbers, the total file length (4-byte little endian at offsets 11 - 14), followed by an 8-byte +3 BASIC header area (bytes 15 - 22) that holds the BASIC file type, file length, load address or line number, or program offset, depending on type. The rest of the header (bytes 23 to 126) are reserved and set to zero, and byte 127 holds a checksum computed as the sum modulo 256 of bytes 0 through 126.

Various apps that use files with this extension

These apps are known to open certain types of BAS files. Remember, different programs may use BAS files for different purposes, so you may need to try out a few of them to be able to open your specific file.

Help us help others

File.org helps thousands of users every day, and we would love to hear from you if you have additional information about BAS file formats, example files, or compatible programs. Please use the links below or email us at submit@file.org to discuss further.