SCEMU The crates.io lib, x86 cpu and systems emulator focused mainly for anti-malware

Related tags

Emulators libscemu
Overview

SCEMU

Usage

Download the maps32.zip or maps64.zip from: https://github.com/sha0coder/scemu/releases/download/maps/maps32.zip https://github.com/sha0coder/scemu/releases/download/maps/maps64.zip

Uncompress it somewhere, in the example it's on /tmp/ but dont use tmp.

Create an emu32 or emu64 and it's important to set the maps folder.

    use libscemu::emu32;


    let mut emu = emu32();
    emu.set_maps_folder("/tmp/maps32/");
    emu.init();

Load your shellcode or PE binary and run the emulator. Zero parameter means emulate for-ever.

    emu.load_code("shellcodes32/shikata.bin");
    emu.set_verbose(2);
    emu.run(0);

Or if you prefer call specific function.

    emu.load_code("samples/malware.exe");

    let crypto_key_gen = 0x40112233;
    let ret_addr = 0x40110000; // any place safe to return.

    let param1 = 0x33;
    let param2_out_buff = emu.alloc("buffer", 1024);

    emu.maps.memset(param2_out_buff, 0, 1024); // non necesary, by default alloc create zeros.
    emu.maps.write_spaced_bytes(param2_out_buff, 
            "DE CC 6C 83 CC F3 66 85 34"); // example of initialization.

    // call function
    emu.regs.set_eip(crypto_key_gen);
    emu.stack_push32(param2_out_buff);
    emu.stack_push32(param1);
    emu.stack_push32(ret_addr);
    emu.run(ret_addr);

    emu.step();

    // check result
    println!("return value: 0x{:x}", emu.regs.get_eax());
    emu.maps.dump(param2_out_buff);
Comments
  • flags out of sync by 0000000144F0F139 | 9C | pushfq |

    flags out of sync by 0000000144F0F139 | 9C | pushfq | 

      {
    "i": 2613,
    "iHex": "a35",
    "x64dbgLine": {
      "rawLine": {
        "Index": "00A35",
        "Address": "0000000144FF3224",
        "Bytes": "4C:8B0E",
        "Disassembly": "mov r9,qword ptr ds:[rsi]",
        "Registers": "r9: FFFFFFFFFFFE5E60-> 292",
        "Memory": "000000000014F488: 292-> 292",
        "Comments": ""
      },
      "rip": "144ff3224",
      "registerChanges": [
        {
          "registerName": "r9",
          "previousValue": "fffffffffffe5e60",
          "newValue": "292"
        }
      ],
      "memoryChanges": [
        {
          "address": "14f488",
          "previousValue": "292",
          "newValue": "292"
        }
      ]
    },
    "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 2613 rip = 144ff3224 r9 fffffffffffe5e60 -> a92;",
        "memTraceLines": []
      },
      "position": "a35",
      "rip": "144ff3224",
      "registerChanges": [
        {
          "registerName": "r9",
          "previousValue": "fffffffffffe5e60",
          "newValue": "a92"
        }
      ],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "newValue mismatch",
        "x64dbg": "292",
        "scemu": "a92"
      }
    ]
  },
    opened by brandonros 11
  • rcr not setting cf to true

    rcr not setting cf to true 

    [
  {
    "i": 2968,
    "iHex": "b98",
    "x64dbgLine": {
      "rawLine": {
        "Index": "00B98",
        "Address": "0000000144EC1D68",
        "Bytes": "81DB 335E463C",
        "Disassembly": "sbb ebx,3C465E33",
        "Registers": "rbx: FFFFFFFFFFFFC81D-> C3B969E9",
        "Memory": "",
        "Comments": ""
      },
      "rip": "144ec1d68",
      "registerChanges": [
        {
          "registerName": "rbx",
          "previousValue": "ffffffffffffc81d",
          "newValue": "c3b969e9"
        }
      ],
      "memoryChanges": []
    },
    "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 2968 rip = 144ec1d68 rbx ffffffffffffc81d -> c3b969ea;",
        "memTraceLines": []
      },
      "position": "b98",
      "rip": "144ec1d68",
      "registerChanges": [
        {
          "registerName": "rbx",
          "previousValue": "ffffffffffffc81d",
          "newValue": "c3b969ea"
        }
      ],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "newValue mismatch",
        "x64dbg": "c3b969e9",
        "scemu": "c3b969ea"
      }
    ]
  },
    opened by brandonros 9
  • neg flags

    neg flags 

    {
    "i": 3165,
    "iHex": "c5d",
    "x64dbgLine": {
      "rawLine": {
        "Index": "00C5D",
        "Address": "0000000144F474DB",
        "Bytes": "9F",
        "Disassembly": "lahf ",
        "Registers": "rax: 8000000-> 8008300",
        "Memory": "",
        "Comments": ""
      },
      "rip": "144f474db",
      "registerChanges": [
        {
          "registerName": "rax",
          "previousValue": "8000000",
          "newValue": "8008300"
        }
      ],
      "memoryChanges": []
    },
    "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 3165 rip = 144f474db rax 8000000 -> 8009300;",
        "memTraceLines": []
      },
      "position": "c5d",
      "rip": "144f474db",
      "registerChanges": [
        {
          "registerName": "rax",
          "previousValue": "8000000",
          "newValue": "8009300"
        }
      ],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "newValue mismatch",
        "x64dbg": "8008300",
        "scemu": "8009300"
      }
    ]
  },
    opened by brandonros 7
  • bsf

    bsf 

    {
    "i": 2993,
    "iHex": "bb1",
    "x64dbgLine": {
      "rawLine": {
        "Index": "00BB1",
        "Address": "000000014501BC20",
        "Bytes": "45:0FBCDF",
        "Disassembly": "bsf r11d,r15d",
        "Registers": "",
        "Memory": "",
        "Comments": ""
      },
      "rip": "14501bc20",
      "registerChanges": [],
      "memoryChanges": []
    },
    "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 2993 rip = 14501bc20 r11 9d46c36de8c10d85 -> e8c10d85;",
        "memTraceLines": [
          {
            "rawLine": "mem_trace: pos = 2993 rip = 14501bc1d op = write bits = 32 address = 0x14f288 value = 0xe8c199fa name = 'stack'",
            "position": "bb1",
            "rip": "14501bc1d",
            "operation": "write",
            "bits": "20",
            "address": "14f288",
            "value": "e8c199fa"
          }
        ]
      },
      "position": "bb1",
      "rip": "14501bc20",
      "registerChanges": [
        {
          "registerName": "r11",
          "previousValue": "9d46c36de8c10d85",
          "newValue": "e8c10d85"
        }
      ],
      "memoryChanges": [
        {
          "address": "14f288",
          "previousValue": 0,
          "newValue": "e8c199fa"
        }
      ]
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "unmatchedRegisterChange mismatch (scemu but not x64dbg)",
        "scemu": "r11"
      }
    ]
  },
    opened by brandonros 7
  • add not setting zf flag

    add not setting zf flag 

    1426 0x144fdff35: mov   r9,[rsi]
	mem_trace: rip = 144fdff35 read 64 bits ->  0x14f498: 0x217  map:'stack'
	diff_flags: rip = 144fdff35 
	diff_reg: rip = 144fdff35 r9 1db36b3a -> 217; 
	rax: 0xfffffffffffeebe0 rbx: 0x3fd49 rcx: 0x0 rdx: 0x74256658f92d6bae rsi: 0x14f498 rdi: 0x144e471d7 rbp: 0x144fdff35 rsp: 0x14f290
	r8: 0x0 r9: 0x217 r10: 0x8bda99a706d29452 r11: 0x7425665806caaf4b r12: 0x1448a76a4 r13: 0x0 r14: 0x140000000 r15: 0x0
	r8u: 0x0 r9u: 0x0 r10u: 0x8bda99a7 r11u: 0x74256658 r12u: 0x1 r13u: 0x0 r14u: 0x1 r15u: 0x0
	r8d: 0x0 r9d: 0x217 r10d: 0x6d29452 r11d: 0x6caaf4b r12d: 0x448a76a4 r13d: 0x0 r14d: 0x40000000 r15d: 0x0
	r8w: 0x0 r9w: 0x217 r10w: 0x9452 r11w: 0xaf4b r12w: 0x76a4 r13w: 0x0 r14w: 0x0 r15w: 0x0
	r8l: 0x0 r9l: 0x17 r10l: 0x52 r11l: 0x4b r12l: 0xa4 r13l: 0x0 r14l: 0x0 r15l: 0x0
	zf: false pf: true af: false of: false sf: false df: false cf: true tf: false if: true nt: false

      {
    "i": 1425,
    "iHex": "591",
    "x64dbgLine": {
      "rawLine": {
        "Index": "00591",
        "Address": "0000000144FDFF35",
        "Bytes": "4C:8B0E",
        "Disassembly": "mov r9,qword ptr ds:[rsi]",
        "Registers": "r9: 1DB36B3A-> 257",
        "Memory": "000000000014F498: 257-> 257",
        "Comments": ""
      },
      "rip": "144fdff35",
      "registerChanges": [
        {
          "registerName": "r9",
          "previousValue": "1db36b3a",
          "newValue": "257"
        }
      ],
      "memoryChanges": [
        "000000000014F498: 257-> 257"
      ]
    },
    "scemuLine": {
      "rawLine": "diff_reg: rip = 144fdff35 r9 1db36b3a -> 217;",
      "rip": "144fdff35",
      "registerChanges": [
        {
          "registerName": "r9",
          "previousValue": "1db36b3a",
          "newValue": "217"
        }
      ],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "newValue mismatch",
        "x64dbg": "257",
        "scemu": "217"
      }
    ]
  },
    opened by brandonros 7
  • rol missetting f_zf

    rol missetting f_zf 

    {
    "i": 76,
    "x64dbgLine": {
      "rawLine": {
        "Index": "0004C",
        "Address": "0000000144FF9602",
        "Bytes": "9F",
        "Disassembly": "lahf ",
        "Registers": "rax: 624-> 4624",
        "Memory": "",
        "Comments": ""
      },
      "rip": "144ff9602",
      "registerChanges": [
        {
          "registerName": "rax",
          "previousValue": "624",
          "newValue": "4624"
        }
      ],
      "memoryChanges": []
    },
    "scemuLine": {
      "rawLine": "diff_reg: rip = 144ff9602",
      "rip": "144ff9602",
      "registerChanges": [],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "unmatchedRegisterChange mismatch (x64dbg but not scemu)",
        "x64dbg": "rax"
      }
    ]
  },
    opened by brandonros 7
  • xor f_pf calculation broken

    xor f_pf calculation broken 

    {
    "i": 436,
    "x64dbgLine": {
      "rawLine": {
        "Index": "001B4",
        "Address": "0000000144FF3291",
        "Bytes": "41:0F9AC2",
        "Disassembly": "setp r10b",
        "Registers": "r10: 8C17F301-> 8C17F300",
        "Memory": "",
        "Comments": ""
      },
      "rip": "144ff3291",
      "registerChanges": [
        {
          "registerName": "r10",
          "previousValue": "8c17f301",
          "newValue": "8c17f300"
        }
      ],
      "memoryChanges": []
    },
    "scemuLine": {
      "rawLine": "diff_reg: rip = 144ff3291",
      "rip": "144ff3291",
      "registerChanges": [],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "unmatchedRegisterChange mismatch (x64dbg but not scemu)",
        "x64dbg": "r10"
      }
    ]
  },
    opened by brandonros 6
  • bsf weirdness

    bsf weirdness 

    {
    "i": 2993,
    "iHex": "bb1",
    "x64dbgLine": {
      "rawLine": {
        "Index": "00BB1",
        "Address": "000000014501BC20",
        "Bytes": "45:0FBCDF",
        "Disassembly": "bsf r11d,r15d",
        "Registers": "",
        "Memory": "",
        "Comments": ""
      },
      "rip": "14501bc20",
      "registerChanges": [],
      "memoryChanges": []
    },
    "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 2993 rip = 14501bc20 r11 9d46c36de8c10d85 -> e8c10d85;",
        "memTraceLines": [
          {
            "rawLine": "mem_trace: pos = 2993 rip = 14501bc1d op = write bits = 32 address = 0x14f288 value = 0xe8c199fa name = 'stack'",
            "position": "bb1",
            "rip": "14501bc1d",
            "operation": "write",
            "bits": "20",
            "address": "14f288",
            "value": "e8c199fa"
          }
        ]
      },
      "position": "bb1",
      "rip": "14501bc20",
      "registerChanges": [
        {
          "registerName": "r11",
          "previousValue": "9d46c36de8c10d85",
          "newValue": "e8c10d85"
        }
      ],
      "memoryChanges": [
        {
          "address": "14f288",
          "previousValue": 0,
          "newValue": "e8c199fa"
        }
      ]
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "unmatchedRegisterChange mismatch (scemu but not x64dbg)",
        "scemu": "r11"
      }
    ]
  },
    opened by brandonros 5
  • dec sf flag incorrect

    dec sf flag incorrect 

    1750 0x144eddda7: cmovs r10d,r12d
	diff_flags: pos = 5451406759 rip = 6d5 
	diff_reg: pos = 1749 rip = 144eddda7 
	rax: 0x29 rbx: 0x3fd49 rcx: 0x0 rdx: 0x74256658f92d6bae rsi: 0x14f4a8 rdi: 0x144e471be rbp: 0x144ed4239 rsp: 0x14f290
	r8: 0x50 r9: 0x0 r10: 0x180200 r11: 0x7425665806ccb42d r12: 0x1448a76a4 r13: 0x0 r14: 0x140000000 r15: 0x0
	r8u: 0x0 r9u: 0x0 r10u: 0x0 r11u: 0x74256658 r12u: 0x1 r13u: 0x0 r14u: 0x1 r15u: 0x0
	r8d: 0x50 r9d: 0x0 r10d: 0x180200 r11d: 0x6ccb42d r12d: 0x448a76a4 r13d: 0x0 r14d: 0x40000000 r15d: 0x0
	r8w: 0x50 r9w: 0x0 r10w: 0x200 r11w: 0xb42d r12w: 0x76a4 r13w: 0x0 r14w: 0x0 r15w: 0x0
	r8l: 0x50 r9l: 0x0 r10l: 0x0 r11l: 0x2d r12l: 0xa4 r13l: 0x0 r14l: 0x0 r15l: 0x0
	zf: false pf: false af: false of: false sf: false df: false cf: true tf: false if: true nt: false
    opened by brandonros 5
  • bsr r11w, cx should not be setting cf flag

    bsr r11w, cx should not be setting cf flag 

    {
    "i": 1712,
    "iHex": "6b0",
    "x64dbgLine": {
      "rawLine": {
        "Index": "006B0",
        "Address": "0000000144FF06A9",
        "Bytes": "41:0F92C3",
        "Disassembly": "setb r11b",
        "Registers": "r11: 74256658F93A644C-> 74256658F93A6400",
        "Memory": "",
        "Comments": ""
      },
      "rip": "144ff06a9",
      "registerChanges": [
        {
          "registerName": "r11",
          "previousValue": "74256658f93a644c",
          "newValue": "74256658f93a6400"
        }
      ],
      "memoryChanges": []
    },
    "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 1712 rip = 144ff06a9 r11 74256658f93a644c -> 74256658f93a6401;",
        "memTraceLines": []
      },
      "position": "6b0",
      "rip": "144ff06a9",
      "registerChanges": [
        {
          "registerName": "r11",
          "previousValue": "74256658f93a644c",
          "newValue": "74256658f93a6401"
        }
      ],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "newValue mismatch",
        "x64dbg": "74256658f93a6400",
        "scemu": "74256658f93a6401"
      }
    ]
  },
    opened by brandonros 4
  • bsr cf flag broken

    bsr cf flag broken 

     {
    "i": 313,
    "x64dbgLine": {
      "rawLine": {
        "Index": "00139",
        "Address": "0000000144F4B8B4",
        "Bytes": "41:80D2 7F",
        "Disassembly": "adc r10b,7F",
        "Registers": "r10: 0-> 7F",
        "Memory": "",
        "Comments": ""
      },
      "rip": "144f4b8b4",
      "registerChanges": [
        {
          "registerName": "r10",
          "previousValue": "0",
          "newValue": "7f"
        }
      ],
      "memoryChanges": []
    },
    "scemuLine": {
      "rawLine": "diff_reg: rip = 144f4b8b4 r10 0 -> 80;",
      "rip": "144f4b8b4",
      "registerChanges": [
        {
          "registerName": "r10",
          "previousValue": "0",
          "newValue": "80"
        }
      ],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "newValue mismatch",
        "x64dbg": "7f",
        "scemu": "80"
      }
    ]
  },
    opened by brandonros 4
  • flags out of sync

    flags out of sync 

     {
    "i": 3356,
    "x64dbgLine": {
      "rawLine": {
        "Index": "00D1C",
        "Address": "0000000144FCC57B",
        "Bytes": "4C:8B0E",
        "Disassembly": "mov r9,qword ptr ds:[rsi]",
        "Registers": "r9: FFFFFFFFFFF9ECA2-> 203",
        "Memory": "000000000014F480: 203-> 203",
        "Comments": ""
      },
      "rip": "144fcc57b",
      "registerChanges": [
        {
          "registerName": "r9",
          "previousValue": "fffffffffff9eca2",
          "newValue": "203"
        }
      ],
      "memoryChanges": [
        {
          "address": "14f480",
          "previousValue": "203",
          "newValue": "203"
        }
      ]
    },
    "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 3356 rip = 144fcc57b r9 fffffffffff9eca2 -> 213;",
        "diffFlagLines": [
          {
            "rawLine": "diff_flags: pos = 3356 rip = 144fcc57b in = 206 out = 206",
            "position": "d1c",
            "rip": "144fcc57b"
          }
        ],
        "memTraceLines": []
      },
      "position": "d1c",
      "rip": "144fcc57b",
      "registerChanges": [
        {
          "registerName": "r9",
          "previousValue": "fffffffffff9eca2",
          "newValue": "213"
        }
      ],
      "memoryChanges": []
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "newValue mismatch",
        "x64dbg": "203",
        "scemu": "213"
      }
    ]
  },
    opened by brandonros 8
  • mem tracing is out of sync by 1 op position compared to x64dbg

    mem tracing is out of sync by 1 op position compared to x64dbg

    this is half nitpick half like "actual problem" in terms of lining up x64dbg vs scemu for comparison

    here is x64dbg line

    {
    "i": 1,
    "iHex": "1",
    "x64dbgLine": {
      "rawLine": {
        "Index": "00001",
        "Address": "00000001448A76A9",
        "Bytes": "E8 C2C96D00",
        "Disassembly": "call dts9_patcherv.144F84070",
        "Registers": "rsp: 14F4A0-> 14F498",
        "Memory": "000000000014F498: 7FFA617547B1-> 1448A76AE",
        "Comments": ""
      },
      "rip": "1448a76a9",
      "registerChanges": [
        {
          "registerName": "rsp",
          "previousValue": "14f4a0",
          "newValue": "14f498"
        }
      ],
      "memoryChanges": [
        {
          "address": "14f498",
          "previousValue": "7ffa617547b1",
          "newValue": "1448a76ae"
        }
      ]
    }

    here is scemu line

        "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 1 rip = 1448a76a9 rsp 14f4a0 -> 14f498;",
        "memTraceLines": [
          {
            "rawLine": "mem_trace: pos = 1 rip = 1448a76a4 op = write bits = 64 address = 0x14f4a8 value = 0x1db36b3a name = 'stack'",
            "position": "1",
            "rip": "1448a76a4",
            "operation": "write",
            "bits": "40",
            "address": "14f4a8",
            "value": "1db36b3a"
          }
        ]
      },
      "position": "1",
      "rip": "1448a76a9",
      "registerChanges": [
        {
          "registerName": "rsp",
          "previousValue": "14f4a0",
          "newValue": "14f498"
        }
      ],
      "memoryChanges": [
        {
          "address": "14f4a8",
          "previousValue": 0,
          "newValue": "1db36b3a"
        }
      ]
    },
    "instructionErrors": [
      {
        "index": 0,
        "message": "unmatchedMemoryChange mismatch (x64dbg but not scemu)",
        "x64dbg": "14f498"
      },
      {
        "index": 0,
        "message": "unmatchedMemoryChange mismatch (scemu but not x64dbg)",
        "scemu": "14f4a8"
      }
    ]
  },

    it isn't until next instruction/position (whatever you want to call it) that we pick up 000000000014F498: 7FFA617547B1-> 1448A76AE memory change

    "scemuLine": {
      "rawLine": {
        "diffRegLine": "diff_reg: pos = 2 rip = 144f84070 rsp 14f498 -> 14f490;",
        "memTraceLines": [
          {
            "rawLine": "mem_trace: pos = 2 rip = 1448a76a9 op = write bits = 64 address = 0x14f4a0 value = 0x1448a76ae name = 'stack'",
            "position": "2",
            "rip": "1448a76a9",
            "operation": "write",
            "bits": "40",
            "address": "14f4a0",
            "value": "1448a76ae"
          }
        ]
      },
      "position": "2",
      "rip": "144f84070",
      "registerChanges": [
        {
          "registerName": "rsp",
          "previousValue": "14f498",
          "newValue": "14f490"
        }
      ],
      "memoryChanges": [
        {
          "address": "14f4a0",
          "previousValue": 0,
          "newValue": "1448a76ae"
        }
      ]
    },

    this isn't necessairly a bug but i'm curious what you recommend/how you would approach/if you can think of a fix

    opened by brandonros 1
Owner
sha0coder
sha0coder
GitHub
Emulator and debugger for LPRS1 ISA & CPU

About LPRSemu is a simple emulator and debugger for LPRS1 ISA & CPU. It supports loading programs from assembly text files, binary string representati

Filip Parag 3 Jan 8, 2023
Intel 8080 cpu emulator by Rust

i8080 i8080 is a emulator for Intel 8080 cpu. 8080 Programmers Manual 8080 opcodes [dependencies] i8080 = { git = "https://github.com/mohanson/i8080"

Mohanson 83 Dec 27, 2022
Non cycle-accurate emulator of the 6502 cpu, written in pure rust

CPU 6502 A non cycle-accurate emulator implementing all legal 6502 opcodes. What does non cycle-accurate mean? Every instruction on the 6502 takes a n

Pietro 10 Jul 15, 2022
A CPU emulator for running unit tests on Game Boy code.

evunit This is a unit testing application for Game Boy roms. It includes a CPU emulator, and loads test configurations from TOML files. Configuring a

Evie M. 8 Jan 1, 2023
Nes-emulator - A NES emulator made to learn the Rust programming language

nes-emulator Building $ rustc --version rustc 1.32.0 (9fda7c223 2019-01-16) $ cargo --version cargo 1.32.0 (8610973aa 2019-01-02) $ cargo build --rel

Michael Burge 225 Dec 23, 2022
Intel 8085 CPU emulation in Rust

PP8085 PP808 is a program that emulates the Intel 8085 Microprocessor architecure. The library is written in Rust and aims to mirror the operation of

Parth Pant 6 Jul 7, 2022
A Game Boy research project and emulator written in Rust

Mooneye GB Mooneye GB is a Game Boy research project and emulator written in Rust. The main goals of this project are accuracy and documentation. Some

Joonas Javanainen 802 Dec 28, 2022
RustBoyAdvance-NG is a Nintendo™ Game Boy Advance emulator and debugger, written in the rust programming language.

RustBoyAdvance-NG Nintendo GameBoy Advance ™ emulator and debugger, written in rust. WebAssembly Demo: https://michelhe.github.io/rustboyadvance-ng/ P

MishMish 510 Dec 30, 2022
TestSuite4 is a framework designed to simplify development and testing of TON Contracts. It includes light-weight emulator of blockchain making it easy to develop contracts.

TestSuite4 0.1.2 TestSuite4 is a framework designed to simplify development and testing of TON Contracts. It contains lightweight blockchain emulator

TON Labs 26 Feb 3, 2022
Learn emulator and programming languages, target chip8, nes, gbc, gba ...

[WIP]learn emulator go-chip8 go run main.go source https://en.wikipedia.org/wiki/CHIP-8 http://devernay.free.fr/hacks/chip8/C8TECH10.HTM https://githu

早晨海风 4 Apr 30, 2021
A NES emulator written in Rust, with a focus on expandability and accuracy

A NES emulator written in Rust, with a focus on expandability and accuracy

Benjamin Mordaunt 4 Sep 19, 2022
Unicorn Emulator Debug Server - Written in Rust, with bindings of C, Go, Java and Python

udbserver - Unicorn Emulator Debug Server When you do emulation with Unicorn Engine, do you want to inspect the inner state during every step? udbserv

Bet4 246 Dec 27, 2022
Learning Rust and ECS by implementing an emulator for Silkroad Online.

Skrillax Learning Rust and ECS by implementing an emulator for an MMORPG. Skrillax is my learning project for playing around with Rust, learning about

Tim Hagemann 10 Dec 22, 2022
🥔 MOS-6502 and NES emulator in Rust (SDL/WebAssembly)

?? Potatis /mos6502 - Generic CPU emulator. Passes all tests, including illegal ops. (No BCD mode). /nes - A very incomplete NES emulator. /nes-sdl -

Henrik Persson 28 Jan 9, 2023
A hardware-accelerated GPU terminal emulator powered by WebGPU, focusing to run in desktops, browsers, tvs and everywhere.

Rio term tl;dr: Rio is a terminal built to run everywhere, as a native desktop applications by Rust/WebGPU or even in the browser powered by WebAssemb

Raphael Amorim 208 Apr 24, 2023
Commodore 64 emulator written in Rust

Rust64 - a C64 emulator written in Rust This is my attempt to study the Rust programming language and have fun at the same time. The goal is to presen

Krzysztof Kondrak 214 Dec 27, 2022
A Flash Player emulator written in Rust

website | demo | nightly builds | wiki Ruffle Ruffle is an Adobe Flash Player emulator written in the Rust programming language. Ruffle targets both t

Ruffle 11.2k Jan 8, 2023
A Gameboy Emulator in Rust

RBoy A Gameboy Color Emulator written in Rust Implemented CPU All instructions correct All timings correct Double speed mode GPU Normal mode Color mod

Mathijs van de Nes 512 Dec 23, 2022
RGB (Rust Game Boy) is a simple emulator for the original game boy

RGB RGB (Rust Game Boy) is a simple emulator for the original game boy and the color game boy. Warning: This no longer compiles in the latest versions

Niven Achenjang 18 Dec 2, 2022