Search › A-Z › V › Vector-06c

Vector-06c

1987 Open source · GPL-2 System ROMs · grey Online

The Vector-06c (Вектор-06Ц) is a 1987 Soviet home computer built around the KR580VM80A — a clone of the Intel 8080 — and famous for its 256-colour palette, wide for its day. This is svofski/vector06js, an original hand-written JavaScript emulator by Viacheslav Slavinsky running on Alexander Demin's i8080.js CPU core; it boots straight to Vektor BASIC in the browser, and because the machine is plain JavaScript objects the shared debugger single-steps authentic 8080 code, sets breakpoints and write watchpoints, and inspects the full 64 KB address space live.

Visit vector06js on GitHub ↗

Visit the official site ↗

Runs on: Web browser

Vector-06c Online Emulator

Play Vector-06c using JavaScript directly in your browser.

Controls

Configurations

Configuration	Emulator	Machine	Legal
Vektor BASIC 2.993	Vector-06c	Vector-06c	grey	Open ⛶
boots v3.0 loader	Vector-06c	Vector-06c	grey	Open ⛶
Test pattern demo	Vector-06c	Vector-06c	open	Open ⛶
Hardware scroll test	Vector-06c	Vector-06c	open	Open ⛶
Border / palette raster test	Vector-06c	Vector-06c	open	Open ⛶
Video sync test	Vector-06c	Vector-06c	open	Open ⛶

Machine

Vector-06c

Chips

Intel 8080

Zilog Z80

Notes

Embedding

The core is svofski/vector06js, an original JavaScript Vector-06c emulator, running on Alexander Demin's i8080.js CPU. It is a set of plain constructors — Memory, IO, I8080, Vector06c — with no wasm heap, so everything the debugger needs is a field or method on a live object.

Boot. Wire the machine exactly like the vendored main.js, but instead of the core's self-scheduling oneFrame() loop, own a requestAnimationFrame loop that calls oneInterrupt() — one TV field (one interrupt period) per call — then displayFrame():

var memory = new Memory();
var io  = new IO(keyboard, timer, memory, ay, floppy, tape);
var cpu = new I8080(memory, io);
var v06c = new Vector06c(cpu, memory, io, ay, tape);
memory.attach_boot(bootRom);          // 2K on-board boot loader at $0000
blkSbr(true, false);                 // reset: pc=0, init the i8253, boot
(function loop(){
  v06c.oneInterrupt(true);            // run one field, or until a breakpoint
  v06c.displayFrame();
  requestAnimationFrame(loop);
})();

A .rom image loads at 00 and is entered via a NOP-slide from $0000 (sp = $C300), the way the machine's own loader launches programs.

Member	Kind	What it does
`cpu.instruction()`	method	Execute exactly one 8080 instruction. The single-step primitive.
`cpu.pc` / `cpu.sp` / `cpu.iff`	field	Live program counter, stack pointer and interrupt flag (plain writable numbers).
`cpu.a()`…`cpu.l()` / `cpu.set_reg(r,v)`	method	The 8080 register file (A B C D E H L); flags are `cpu.sf .zf .hf .pf .cf`.
`memory.read(a)` / `.write(a,v)`	method	The banked address space the CPU sees — side-effect-free, safe to poll live.
`v06c.oneInterrupt()`	method	Run one TV field; internally steps the CPU and shifts pixels through the palette.

Debugger integration

The plug-in (vector06c-debug.js) describes the machine to the shared debugger; the controllable loop lives in vector06c-machine.js:

Registers are read live from the 8080 core each refresh (A, B, C, D, E, H, L, SP, PC, IFF and the S Z H P C flags) and written straight back through set_reg and the flag fields.
Disassembly uses the shared z80 decoder: the Z80 is a superset of the 8080, so it renders KR580VM80A code correctly, mnemonics and all.
Memory is the full 64 KB CPU view plus the 2 KB boot-ROM overlay, read side-effect-free.
Single step is one cpu.instruction(). Breakpoints reuse the core's own once-per-instruction hook (v06c.dbg.check_breakpoint()) against a PC set. Write watchpoints wrap Memory.write — the one path every CPU store passes through — and pause on a store to a watched address.

Architecture

The Vector-06c (Вектор-06Ц, 1987) is a Soviet home computer designed by Donat Temirazov and Alexander Sokolov. Its CPU is the KR580VM80A (КР580ВМ80А), a Soviet clone of the Intel 8080 running at 3 MHz.

Video — a bit-plane framebuffer (four 8 KB planes) shifted through a 16-entry palette selected from 256 colours, with hardware vertical scroll and a coloured border. The palette and border can be rewritten mid-scanline, which the pixel filler models cycle-accurately.
I/O — two KR580VV55 (Intel 8255) parallel interfaces drive the keyboard matrix, border, video mode and palette latch; a KR580VI53 (Intel 8253) timer feeds the sound; an AY-3-8910-style chip and a Covox add audio; a KR1818VG93 (FD1793) handles floppy disks.
Memory — 64 KB RAM with a bank-switched extension (the "quasi-disk"), overlaid at reset by a 2 KB boot ROM. This build boots to Vektor BASIC by default, with the on-ROM "boots" loader and a set of raster/palette test programs as extra configurations.