Free snes emulators software for linux

Wide Area Link Emulator enables you to set and test various parameters of a WAN access link (also known as a bottleneck link) before testing on a fully-functional network.

Any ISP has a high bandwidth LAN (of the order of tens of Mbps, e.g. Ethernet) and a WAN access link with relatively low speeds (of the order of a few Kbps to a few Mbps). To be able to evaluate the ISPs performance, actual tests will have to be conducted on a live, fully functional network. This would imply enabling certain features in communication equipment which could be detrimental to the proper functioning of a commissioned network. To address such a problem of being able to characterize/quantify the network operation in terms of its performance with respect to various parameters, a test-bed emulating the ISPs connectivity to the Internet would be an ideal solution.

An important factor in setting up such a test-bed, is emulating the WAN Access Link. Using complex hardware is costly. Such a link can however be easily implemented by emulating the scenario on popular physical technology such as Ethernet. By changing the TCP/IP stack on a Personal Computer, the rate at which packets are injected into the network can be controlled and other necessary features can easily be added.

WALE was implemented in 2 phases and the first version can emulated bandwidths up to 8Mbps and uses FIFO queues with drop-tail.

WALE v2 can emulate bandwidths of up to 80Mbps(a 10-fold improvement over version 1) due to the stripped down version of Micro-second resolution timer being used in the Linux kernel. WALE also implements differentiated services are recommended by IETF. A hash-based packet classifier is used to classify packets into one of 3 queues (Expedited Forwarding, Assured Forwarding and Best Effort). A simple priority scheduling has been implemented between the queues.

Version 2 has been implemented in the Generic Device Layer of the Linux Kernel. The kernel version is 2.2.19. WALE2 kernel patch can be downloaded here. An ncurses based front end has been implemented for setting and viewing various parameters of the bottleneck link.

Jagacy 3270 Emulator is a feature-rich 3270 terminal emulator. It supports SSL, TN3270E, and over thirty languages. The project does not contain the screen-scraping library, and is a cost effective solution for a stand-alone Java 3270 terminal emulator.
The emulator can be configured to help create screen-scraping applications. Developers can also develop their own custom terminal emulators (with automated logon and logoff). Jagacy 3270 screen-scraping is faster, easier to use, and more intuitive than HLLAPI. It excels in creating applications reliably and quickly.
Main features:
- 100% pure Java.
- Feature rich 3270 terminal emulator.
- SSL support.
- Extended TN3270 (TN3270E) support.
- 17 different terminal types (including 132 columns).
- Internationalization support. Over 30 different languages supported.
- Configurable using properties, if desired. No changes necessary when host name or screens change.
- Easily create a custom 3270 terminal emulator.
- Small footprint (less than 150K). Runs efficiently within the Eclipse and NetBeans IDEs.
- Can display the 3270 session in a window while an application is running.
- Includes a full-featured 3270 terminal emulator tailored to developing and debugging applications.
Enhancements:
- Add features/limitations/changes here

cereal is an emulation framework designed to allow easy emulation of interconnected modules. Its main component is an 8051 emulator module, so it can be used as an 8051 emulator.

The reason for writing cereal was an 8051 embedded controller which should control an engine using pulse-width modulation, read the resulting flow from a flowmeter, and regulate the output to keep flow at a given value.

In the real world, it takes about two seconds for the algorithm to stabilize, and emulating two seconds using conventional emulators (computing the engine input, the real flow, the feedback frequency) by hand is simply impossible to do.

Using cereal, it took about two hours to create a module emulating the engine/flowmeter combination, along with a window showing the current values. Then it is trivial to connect this module to the 8051 module and just sit back and watch the result.

Another, more trivial example is a multiplexed display/keyboard combination (in my case, selecting one of four 8-segment LCD displays). Instead of watching the port bits, why not create a module that shows the output graphically as four displays?

In addition to these possibilities, cereal offers breakpoints, watches, evaluate/modify dialog (which can solve 2 * x + 1 = 5). The KDE GUI also can be extended using KParts (8051 interface is provided as a KParts plugin).

Also included is a command interface usable for creating testsuites for your programs (or for cereal itself - cereal has over 400 tests in its testsuite), and a simple 8051 disassembler.

GSnes9x project is a GNOME front end for the Snes9X SNES emulator
GSnes9x is a GNOME front-end for the Snes9X SNES emulator.
It allows setting and preservation of options for each ROM, and keeps a Cheat Codes database, an unlimited amount of codes can be stored.
Enhancements:
- Version 3.12 release
- remove help hackery, use Gnome help system
- include Snes9x Readme v1.37
- patch to use GSNES9X_IMAGE_DIR environment variable from morpheus2371
- Gnomified image loading

This program reads symbolic 65816 or 65c816 machine code and compiles (assembles) it into a relocatable object file.
The produced object file is binary-compatible with those made with XA65.
This program was born when Bisqwit needed a relocatable object -producing snes assembler and XA65 had too many bugs in it.
He was unable to fix the XA65 source so he started his own project, aiming for enough compatibility to be able to use the assembly files already written in the XAxa65 syntax.
Since that, this program has been growing to meet the needs in SNES game and patch development.
The following mnemonics are supported:
adc, and, asl, bcc, bcs, beq, bit, bmi, bne, bpl, bra, brk, brl, bvc, bvs, clc, cld, cli, clv, cmp, cop, cpx, cpy, db , dec, dex, dey, eor, inc, inx, iny, jml, jmp, jsl, jsr, lda, ldx, ldy, lsr, mvn, mvp, nop, ora, pea, pei, per, pha, phb, phd, phk, php, phx, phy, pla, plb, pld, plp, plx, ply, rep, rol, ror, rti, rtl, rts, sbc, sec, sed, sei, sep, sta, stp, stx, sty, stz, tax, tay, tcd, tcs, tdc, trb, tsb, tsc, tsx, txa, txs, txy, tya, tyx, wai, xba, xce
All the standard addressing modes of the 65816 cpu are supported.
Syntax:
- Implied: nop; clc
- Immediate: lda #value; rep #value etc (size may depend on an operand size setting)
- Short relative: bra end
- Long relative: brl end; per end+2
- Direct: lda $12
- Direct indexed: lda $12,x; lda $12,y
- Direct indirect: lda ($12); pei ($12)
- Direct indexed indirect: lda ($12,x)
- Direct indirect indexed: lda ($12),y
- Direct indirect long: lda [$12]
- Direct indirect indexed long: lda [$12],y
- Absolute: lda $1234
- Absolute indexed: lda $1234,x; lda $1234,y
- Absolute long: lda $123456
- Absolute indexed long: lda $123456,x
- Stack-relative: lda $12,s
- Stack-relative indirect indexed: lda ($12,s),y
- Absolute indirect: lda ($1234)
- Absolute indirect long: lda [$1234]
- Absolute indexed indirect: lda ($1234,x)
- MVN/MVP: mvn $7E,$7F
For reference, in Intel syntax it would be something like this (not supported by snescom):
- Implied: nop; clc
- Immediate: lda value; rep value etc (size may depend on an operand size setting)
- Short relative: bra end
- Long relative: brl end; per end+2
- Direct: lda [$00:d+$12]
- Direct indexed: lda [$00:d+$12+x]; lda [$00:d+$12+y]
- Direct indirect: lda [db:[$00:d+$12]]; pei [db:[$00:d+$12]]
- Direct indexed indirect: lda [db:[$00:d+$12+x]]
- Direct indirect indexed: lda [db:[$00:d+$12]+y]
- Direct indirect long: lda [long[$00:d+$12]]
- Direct indirect indexed long: lda [long[$00:d+$12]+y]
- Absolute: lda [db:$1234]
- Absolute indexed: lda [db:$1234+x]; lda [db:$1234+y]
- Absolute long: lda [$12:$3456]
- Absolute indexed long: lda [$12:$3456+x]
- Stack-relative: lda [$00:$12+s]
- Stack-relative indirect indexed: lda [db:[$00:$12+s]+y]
- Absolute indirect: lda [db:[$1234]]
- Absolute indirect long: lda [long[db:$1234]]
- Absolute indexed indirect: lda [db:[db:$1234+x]]
- MVN/MVP: mvn $7E,$7F
Enhancements:
- This release updates the linker program, adding a feature to output raw files, or even ROM files directly in the SMC format, with proper checksums.
- The error handling of the assembler was improved somewhat.

The P65 assemblers are assemblers for the 6502 microprocessor (such as is used in the Commodore 64, Apple II, and Nintendo Entertainment System).
They are designed to be able to support a wide variety of output formats, both to support multiple target platforms and to produce code for emulators.
The eventual goal of P65 is to be as expressive as the more powerful assemblers of the late 80s, such as DASM. Its not there yet, but its getting there.
Main features:
- Highly portable - All versions of P65 are written in portable scripting languages. The original releases were done in Perl. While P65-Perl 1.1 is stable and reasonably powerful, it lacks some major features, such as modules and macros. P65-Ophis, the Python port, will run on slightly fewer architectures, but will still run on all current major systems.
- Flexible output format - P65 allows for very flexible control over data and assemble points. Output file formats are completely independent of the final memory maps.
- Multiple file support - libraries may be kept as seperate files and included seperately, facilitating code reuse.
- Temporary label support - source may contain "anonymous labels" that help decrease namespace pollution. P65-Ophis also supports named temporary labels that only exist within a well-defined scope.
- Assemble-time expressions - P65-Ophis supports High-byte/low-byte computations along with bitmasking and traditional arithmetic operations in code and data statements. Access to the current PC is also supported. P65-Perls expressions are more limited but are generally sufficient.
- Symbol table management - Allows for creating labels and data constants outside of the code, and for allocating RAM symbolically. This includes full support for segments.
- Optimal instruction selection - Compresses as many instructions as possible into zero page format. If this compression permits other instructions to become zero page instructions, it will compress those as well.

Gemu News is a SuperKaramba theme that displays the latest version of compatibility layers like wine and the latest version of emulators like dosbox. The version of xqf is also listend.

By clicking on the globe youll get on the homepage of the driver/tool.

Im looking forward for your feedback.

DeSmuME project is a Nintendo DS emulator that can run both commercial games and homebrew applications.

The original author of DeSmuME is YopYop156. He has stopped working on it on the beginning of april 2006 and passed the torch to a new team of developers. You can now follow the progress of DeSmuME on this site.