Displaying 1 to 20 from 24 results

reactos - A free Windows-compatible Operating System

ReactOS™ is an Open Source effort to develop a quality operating system that is compatible with applications and drivers written for the Microsoft® Windows™ NT family of operating systems (NT4, 2000, XP, 2003, Vista, Seven). The ReactOS project, although currently focused on Windows Server 2003 compatibility, is always keeping an eye toward compatibility with Windows Vista and future Windows NT releases.

mcsema - Framework for lifting x86, amd64, and aarch64 program binaries to LLVM bitcode

McSema is an executable lifter. It translates ("lifts") executable binaries from native machine code to LLVM bitcode. LLVM bitcode is an intermediate representation form of a program that was originally created for the retargetable LLVM compiler, but which is also very useful for performing program analysis methods that would not be possible to perform on an executable binary directly. McSema enables analysts to find and retroactively harden binary programs against security bugs, independently validate vendor source code, and generate application tests with high code coverage. McSema isn’t just for static analysis. The lifted LLVM bitcode can also be fuzzed with libFuzzer, an LLVM-based instrumented fuzzer that would otherwise require the target source code. The lifted bitcode can even be compiled back into a runnable program! This is a procedure known as static binary rewriting, binary translation, or binary recompilation.

likwid - Performance monitoring and benchmarking suite

Likwid is a simple to install and use toolsuite of command line applications for performance oriented programmers. It works for Intel and AMD processors on the Linux operating system.For further information please take a look at the Wiki.

x86-assembly-cheat - x86 userland minimal examples tutorial

x86 userland minimal examples tutorial. Hundreds of runnable asserts. IO done with libc, so OS portable in theory. Tested in Ubuntu 14.04. Containers (ELF), linking, calling conventions. System land cheat at: https://github.com/cirosantilli/x86-bare-metal-examples

Browser Gallese

Browser Gallese is a handy and reliable utility designed to enable users to surf the web from a friendly and easy-to-use GUI.

x86/x86-64 assembler/jitter written in C#

The project goal is to develop a library for generating machine code irrelatively to machine architecture. Assembler-like C# API is a bonus.

arch - Better `os.arch()` for node and the browser -- detect OS architecture

This module is used by WebTorrent Desktop to determine if the user is on a 32-bit vs. 64-bit operating system to offer the right app installer.In Node.js, the os.arch() method (and process.arch property) returns a string identifying the operating system CPU architecture for which the Node.js binary was compiled.

jemul8 - An object-oriented JavaScript x86 Emulator for Node.js and the browser

An object-oriented JavaScript x86 Emulator for Node.js and the browser. jemul8 takes an object-oriented approach to emulation. Primarily an educational tool, it aims to provide a detailed description of the internal workings of an IBM-compatible PC.

xelix - An experimental monolithic x86 kernel aiming for POSIX compatibility.

Xelix is an open source (GPL v3+ licensed) kernel, mainly for learning how things work inside of a computer. It currently only supports x86. Steps in braces don't neccessarily have to be executed every time you compile Xelix. If you're compiling the first time, run them.

node-capstone - Node

node-capstone provides Node.js bindings for the Capstone disassembler library, allowing binary data in Buffer objects to be disassembled using any of Capstone's supported architectures. On Windows and Linux, install a pre-compiled binary from the Capstone download page, or build from source.

microx - Safely execute an arbitrary x86 instruction

Microx is a single-instruction "micro execution" framework. Microx enables a program to safely execute an arbitrary x86 or x86-64 instruction. Microx does not take over or require a process context in order to execute an instruction. It is easily embedded within other programs, as exampled by the Python bindings. The microx approach to safe instruction execution of arbitrary instructions is to require the user of microx to manage machine state. Microx is packaged as a C++ Executor class that must be extended. The Python bindings also present a class, microx.Executor, that must be extended. A program extending this class must implement methods such as ReadReg and ReadMem. When supplied with instruction bytes, microx will invoke the class methods in order to pull in the minimal requisite machine state to execute the instruction. After executing the instruction, microx will "report back" the state changes induced by the instruction's execution, again via methods like WriteReg and WriteMem.

remill - Library for lifting of x86, amd64, and aarch64 machine code to LLVM bitcode

Remill is a static binary translator that translates machine code instructions into LLVM bitcode. It translates x86 and amd64 machine code (including AVX and AVX512) into LLVM bitcode. AArch64 support is underway. Remill focuses on accurately lifting instructions. It is meant to be used as a library for other tools, e.g. McSema.

lbForth - Self-hosting metacompiled Forth, bootstrapping from a few lines of C; targets Linux, Windows, ARM, RISC-V, 68000, PDP-11, asm

This is a self-hosted implementation of Forth, which can regenerate itself from Forth source code. The bootstrapping process uses a metacompiler written in Lisp to target a small inner interpreter and a handful of code words written in C. A new metacompiler written in Forth generates an x86 executable using using assembly language code words. There are also ARM, RISC-V, Motorola 68000, PDP-11, and asm.js targets. There is a cross compiler for 6502, 8051, AVR, Cortex-M, MSP430, PDP-8, PIC, and STM8.

80x86 - 80186 compatible SystemVerilog CPU core and FPGA reference design

The S80186 IP core is a compact, 80186 binary compatible core, implementing the full 80186 ISA suitable for integration into FPGA/ASIC designs. The core executes most instructions in far fewer cycles than the original Intel 8086, and in many cases, fewer cycles than the 80286. The core is supplied as synthesizable SystemVerilog, along with a C++ reference model, extensive tests, a reference BIOS implementation and reference FPGA designs. This will build the Docker containers and then perform a release build and run all of the tests.

third - Third, a small Forth compiler for 8086 DOS

Historical note: I wrote this in 1998 (when I was 16), so I'm just putting it up here as a backup and for "historical interest". It's still a pretty good show-case for how simple a self-hosting Forth compiler can be. I wrote it more or less all myself (though parts of the assembler were pretty much copied, I think :-), but it's loosely based on eForth and the Forth compilers my dad wrote.

nemesis - :floppy_disk: x86 operation system writen on fasm

Nemesis is x86 operation system written on fasm. You can find more information or try online. You can build image or just downlod it.

simple-pt - Simple Intel CPU processor tracing on Linux

simple-pt is a simple implementation of Intel Processor Trace (PT) on Linux. PT can trace all branches executed by the CPU at the hardware level with moderate overhead. simple-pt then decodes the branch trace and displays a function or instruction level trace. PT is supported on Intel 5th generation Core (Broadwell), 6th generation Core (Skylake) CPUs, and later, as well as Goldmont based Atom CPUs (Intel Joule, Apollo Lake) and later.

baresifter - A bare-metal x86 instruction set fuzzer a la Sandsifter

Baresifter is a 64-bit x86 instruction set fuzzer modeled after Sandsifter. In contrast to Sandsifter, Baresifter is intended to run bare-metal without any operating system. When loaded, the main fuzzing logic runs in ring0 as a tiny kernel. To safely execute arbitrary instructions, baresifter creates a single executable page in ring3 user space. For every instruction candidate, baresifter writes the instruction bytes to this user space page and attempts to execute it by exiting to user space. It follows the same algorithm as outlined in the original Sandsifter paper to find interesting instructions and guess instruction length.

Quasar - A tiny operating system micro kernel. (A.k.A. SegfaultOS). Written in Rust

The Makefile exports a make iso target to build a minimal iso image based on GRUB2, as well as a make run target to run the generated image with QEMU.