Free c64 software for linux

c64img is a PHP script that converts an image (JPEG, PNG, or GIF) to an image that can be shown on a Commodore 64 (FLI style).
It searches for the best possible colors in the 160x200 (X-doubled) resolution, and uses a simple dithering method to distribute errors.
This project outputs a 640x200 image consisting of the resampled original on the left and the dithered C64 image on the right.
Enhancements:
- Major feature enhancements were made.
- The following options were added: "size=double" to double the size of the output image, "show=c64" to show only the c64 image, "dither=[0-100]" to dither by a percentage (default: 50%), and "palette=[c64s|ccs64|frodo|godot|pc64|vice|pepto]" to select a palette.

VICE is a program that runs on a Unix, MS-DOS, Win32, OS/2, Acorn RISC OS, QNX 6.x or BeOS machine and executes programs intended for the old 8-bit computers.

The current version of VICE emulates the C64, the C128, the VIC20, all the PET models (except the SuperPET 9000, which is out of line anyway), the PLUS4 and the CBM-II (aka C610).

If you have any comments or bug reports, please contact us at one of the addresses given below.

VICE is under constant change. Anyone interested in helping development of VICE is welcome. Please contact us to avoid doing something that someone else has done already.

Of course our warm thanks go to everyone who has helped us in developing VICE during these past few years.

Koncert project is an arcade videogame clone for KDE/Qt.
Koncert is a clone of an old C64 arcade game (Rootin Tootin), written for KDE/Qt. Its part of the K64 project.
Installation guide:
# bzip2 -cd koncert-0.1.tar.bz2 | tar xf -
# cd koncert
# ./configure
# make
# make install
Enhancements:
- Added a levels editor.
- Made some bugfixes.

TinySID project is the smallest SID player available. Its most advantage lies in its unique HardSID support, that is:
- exact C64 PC cycle syncronizing
- multispeed tunes will use the same timing a real C64 does
- improved HardSID sample output (includes mixer)
- support for multiprocessor systems
- Previous versions required just 20kbyte disk space. This was however skipped due to 64bit support.
Main features:
- Multiplatform
- Native 32/64 bit windows support
- Runs on Unix/linux platform
- Playstation Portable (PSP) version available
- Also incorporated in rockbox for portable mp3 players
- Accurate playback on both hardsid and software emulation, includes multispeed tunes
- Digitized sample playback on both hardsid and software emulation
- 99% 6510 cpu emulation (still some bugs to fix)
- Fat 6581 SID emulation, including filters. Sounds different than other players!
Please note that TinySID has nothing to do with other projects such as SIDPlay. The 6510/6581 emulation is based on routines by Tammo Hinrichs (kb) and has been further developed.
Enhancements:
- This release added support for multi-speed tunes and digi-playback.
- Bugs in CPU emulation and endian neutral code were fixed.
- Speedups were achieved in the synth renderer.

CBM Dasm project is a Commodore related application to disassemble C64/VIC20a executable programs.
CBM Dasm is a tool to generate an easily readable and printable assembly listing in ASCII format of CBM binaries (C64/VIC20 etc.) saved as Prg files.
Main features:
- Optional source addresses
- Optional raw hex values
- Optional C64 Comments
- Optional Pseudo OPs listing
- Org address selection
Enhancements:
- This version comes with a new feature that lets the user mark certain areas of the input file so that these do not get disassembled.
- Of course the user can save/restore custom ranges in a single group and include/exclude them individually.

The Contiki Operating System is mostly known as an operating system for networked embedded systems. A few years ago, however, Contikis primary claim to fame was its Commodore 64 port.
With the help of JAC64, a Java-based C64 emulator developed by my colleague and fellow Contiki developer Joakim Eriksson, you can now experience the C64 port of Contiki 1.2-devel1 again, directly in your web browser!
Enhancements:
- Contiki now does dynamic run-time loading and linking of standard ELF files.
- Rime, a protocol stack designed for low-power radio communication, has been added.
- Cooja, a Java-based network simulator for Contiki is included.
- The build system has been reworked to allow for easy cross-compiling for many platforms.
- A new port for the Tmote Sky sensor board has been added.

Meta::Widget::Gtk::Sprite is a Perl module to do C64 style sprites.

SYNOPSIS
use Gtk;
use Gnome;
init Gnome "test.pl";
use Meta::Widget::Gtk::Sprite;
my $mw = new Gtk::Window( "toplevel" );
my($canvas) = Gnome::Canvas->new() ;
$mw->add($canvas );
$canvas->show;
my $croot = $canvas->root;
my $sprites = new Meta::Widget::Gtk::Sprite($croot);
my $p1 = $sprites->create("./player1.xpm", 100, 0);
$sprites->slide_to_time($p1,5000, 100, 100);
my $p2 = $sprites->create("./player2.xpm", 0, 0);
$sprites->slide_to_speed($p2,10, 100, 100);
$sprites->set_collision_handler(&Bang);
$mw->show;
Gtk->main;
sub Bang
{
print "Bang!n";
exit;
}

Sprite is a module to bring back the simple graphics programming of the C64 (hopefully without the lookslikearse component). You can declare pictures to be sprites on the canvas, and then move them around and crash them into each other.

NOTE
The canvas is the Gnome::Canvas object. You have to have a Gtk::Canvas object before starting Sprite.

METHODS
new Meta::Widget::Gtk::Sprite( $canvas_root );

The new method takes one argument, the canvas root object for the canvas you want to draw on.

You may obtain the canvas root from your canvas like this:

my $croot = $canvas->root;

$sprite_number = $sprites->create("/path/to/filename", 10, 20);
Create will load an image file (right now, only xpm format) from disk and make a sprite out of it. The two numbers are the x and y position on the canvas.

$sprites->show( $sprite_number );
Makes the sprite appear on the canvas

$sprites->hide( $sprite_number );
Make the sprite picture disappear from the canvas. Note that it can still collide with other sprites. If you dont want it to hit anything, move it out of the way or ignore it in your own collision handler.

$sprites->destroy( $sprite_number );
Completely destroys a sprite.

$sprites->move_to( $sprite_number, 10, 20 );
Teleports the sprite named in $sprite_number to the position given immediately. Contrast slide_to_xxx functions.

$sprites->slide_to_time( $sprite_number, $time, 10, 20 );
Will make the sprite $sprite_number slide across the canvas to the position 10, 20. It will take $time seconds to do so. Slow speeds will appear jerky.

$sprites->slide_to_speed( $sprite_number, $speed, 10, 20);
Will slide the sprite $sprite_number to the position 10, 20. It will move at a speed of $speed pixels per second.

$sprites->pos( $sprite_number);
Returns the x and y coordinates of $sprite_number

$sprites->velocity( $sprite_number, 5, 6);
Sets the speed of $sprite_number. The numbers are the x and y speeds. Negative numbers will make the sprite go backwards.

$sprites->set_collision_handler ( &collision_handler );
Name a function that will be called when two sprites collide. Note that the collision detection system is extremely crappy right now. It turns out that it is very difficult to efficiently detect collisions.

Your function will be called like this:

collision_handler( $sprite_number, $sprite_number);

where the two sprite numbers are the two sprites that collided. Multiple sprites colliding will cause many collision handler callbacks.

Note well that if you set the collision handler Sprite.pm will check every single sprite for collisions every animation loop. I havent optimised this, so you will notice a massive slowdown as you add more sprites.

To switch collisions checking off, set the handler to undef:

$sprites->set_collision_handler ( undef );

Main features:
- Fast
- SNES support
- SMS/GG support
- Gameboy support
- PC-Engine support
- NO$GMB symbol file writing
- Support for object and library files
- You can patch ROM images with code
- WLA GB-Z80 disassembler included
- Numerous ways to comment code away
- ROM image and program file compiling
- Multilevel macros (actually, functions)
Compiles code for the following CPUs:
- 6502 (NES, etc.)
- 65C02 (VIC-20, etc.)
- 6510 (C64, etc.)
- 65816 (SNES, etc.)
- GB-Z80 (Game Boy)
- HuC6280 (PC-Engine)
- SPC-700 (SNES sound chip)
- Z80 (GG, SMS, MSX, Spectrum, Ti86, etc.)
... on the following platforms:
- AmigaOS 1-3 (680x0)
- AmigaOS 4 (PPC)
- Linux
- MSDOS
- Un*x
- Win32
Currently WLA can also be used as a patch tool. Just include the original
ROM image into the project with .BACKGROUND and insert e.g., OVERWRITE .SECTIONs
to patch the desired areas. Output the data into a new ROM image and there
you have it. 100% readable (asm coded) patches are reality!
Note that you can directly compile only object and library files. You must
use WLALINK to link these (or only one, if you must) into a ROM/program file.
About the names... WLA DX means all the tools covered in this documentation.
So WLA DX includes WLA GB-Z80/Z80/6502/65C02/6510/65816/HUC6280/SPC-700
macro assembler (what a horribly long name), WLAB, WLAD and WLALINK
GB-Z80/Z80/6502/65C02/6510/65816/HUC6280/SPC-700 linker. I use plain WLA to refer
to the macro assembler.
Enhancements:
- A couple of new directives, directive aliases, makefiles, and examples were added. .MEMORYMAP and .MACRO parsing were enhanced.
- This release incorporates a few 6502 related fixes.