Displaying 1 to 20 from 20 results

glsl-optimizer - GLSL optimizer based on Mesa's GLSL compiler

  •    C++

A C++ library that takes GLSL shaders, does some GPU-independent optimizations on them and outputs GLSL or Metal source back. Optimizations are function inlining, dead code removal, copy propagation, constant folding, constant propagation, arithmetic optimizations and so on. Apparently quite a few mobile platforms are pretty bad at optimizing shaders; and unfortunately they also lack offline shader compilers. So using a GLSL optimizer offline before can make the shader run much faster on a platform like that. See performance numbers in this blog post.

Haxe - The Cross-Platform Toolkit

  •    Haxe

Haxe is an open source toolkit that allows you to easily build cross-platform tools and applications that target many mainstream platforms.

crossbuild - :earth_africa: multiarch cross compiling environments

  •    Dockerfile

This is a multiarch Docker build environment image. You can use this image to produce binaries for multiple architectures. OSX/Darwin/Apple builds: Please ensure you have read and understood the Xcode license terms before continuing.

OpenEmbedded - Build Framework for Embedded Linux

  •    C

OpenEmbedded is the build framework for embedded Linux. It offers a best-in-class cross-compile environment. It allows developers to create a complete Linux Distribution for embedded systems. It support for many hardware architectures. It supports cross-compiles 1000's of packages including GTK+, Qt, the X Windows system, Mono, Java, and about anything else you might ever need.

hlsl2glslfork - HLSL to GLSL language translator based on ATI's HLSL2GLSL. Used in Unity.

  •    C++

DX9 style HLSL in, GLSL / GLSL ES out. For an opposite tool (GLSL ES to HLSL translator), look at Google's ANGLE.

Kernel Development Kit (KDK)


Build your own os, with the help of Kernel Developent Kit. With minimal Assembly and C code, around 99.9% of the code is written in C++ using object oriented design.

ewxb_gcc_cross-compiler_builder - Build a full GCC+glibc toolchain from scratch (with Go support)

  •    Shell

This is a script documenting the steps and phases take when I compiled a GCC cross toolchain for GCC 4.9 head (with Go support). Building a cross-compiler is complex due to dependencies so a lot of bootstrapping has to be done. This script is inspired by Jim Blandy's excellent eglibc cross-compiling guide posted at eglibc's mailinglist at [patches] Cross-building instructions. This script can serve as a starting point for those who want to build a x-toolchain from scratch. Don't expect it to work in directly as it's tailored for my setup. Instead you can re-use the phases and modify the script with parameters that you need. The last phases adds Go support, which is easy to comment out if you're only interested in a C/C++ compiler.

nybbleForth - Stack machine with 4-bit instructions

  •    Forth

Stack machine with 4-bit instructions. There's a simulator, an assembler, a cross compiler, and a Forth kernel, all written in Forth. There's a hardware design written in Verilog.

xForth - Experimental Forth cross compiler for tiny devices

  •    Forth

This is a Forth cross compiler for tiny devices. It's based on lbForth. Supported targets are 8051, AVR, Cortex-M, MSP430, PIC, and STM8. There's also support for some classic machines: 6502 and PDP-8. This is a temporary battleground to get things up and running. I expect to fold the finished result back into lbForth.

zipcpu - A small, light weight, RISC CPU soft core

  •    Verilog

If you'd like to get started with the ZipCPU, you might wish to know that this repository contains the CPU, its documentation, and the toolchain. The CPU implementation found here, though, is just that: a CPU. This implementation requires a bus with peripherals hanging off of it, things such as RAM, flash (ROM), serial port, etc. This is just where I keep the CPU apart from any necessary peripherals. So, if you want to try out the CPU, feel free to download and build this repository (use git-clone with a depth of 1--there's a lot of stuff in the git repo that you don't necessarily need). You'll need it for the binutils, GCC, and newlib support provided by it.

linux-lab - Docker/Qemu Based Linux Kernel Development Environment

  •    C

This project aims to create a Qemu-based Linux development Lab to easier the learning and development of Linux Kernel. For Linux 0.11, please try our Linux 0.11 Lab.

tensorflow-build - A set of scripts to (cross-)build the Tensorflow C lib for various architectures / OS

  •    Shell

We're using these scripts on Ubuntu and Archlinux, the commands given below assume that you're on a fairly recent Ubuntu box. Theses script are a WIP but a good starting point on how to cross compile tensorflow. Expect to have to edit and tweak them to fit your needs.

gobuildall - Builds Go packages for every OS and architecture

  •    Go

gobuildall runs the go build command for every supported OS and architecture combination. If arguments are specified, they are passed to the go build command. Executables for each combination are output to files named as os-architecture.

javascript-to-clojurescript - JavaScript to ClojureScript translator

  •    Javascript

This tool tries to translate as much JavaScript code into ClojureScript as it can. Keep in mind that it might fail or the result will be non-idiomatic Clojure code due to substantial differences between languages. Use for educational purpose.

nixcrpkgs - Nice nix expressions for cross-compiling.

  •    Nix

nixcrpkgs is a collection of tools for cross-compiling statically-linked, standalone software applications. With nixcrpkgs, you can specify what platforms you want to target, what libraries and build tools you depend on, and the commands that build your software. When you build your software, nixcrpkgs will automatically take care of building or retrieving everything you need, including cross-compilers and libraries. nixcrpkgs primarily consists of Nix expressions, which are recipes for building software with Nix, the purely functional package manager. These recipes build on top of the Nix Packages collection (Nixpkgs).

corollary - Cross-compiler from Haskell to Rust, plus parser-haskell.

  •    Rust

Corollary is a very experimental Haskell to Rust compiler. The goal is to automate the syntatic conversion of Haskell into Rust, letting users manually finish the conversion into idiomatic Rust code. Along with an (extremely loose) adaptation of Haskell methods in corollary-support, this can expediate the process of completing a full port. Current status: Looking for maintainers. Corollary can parse and translate entire files, with varying results. Source code specific hacks, along with manual translation, were used for the language-c port of Haskell's C parsing library.

rust-on-raspberry-docker - cross compiling rust for the raspberry pi in a docker container

  •    Shell

Since Rust version 1.23.0 the docker images is based on Debian stretch. Please report any issues you have with this update in the issue section of this repo. The native process, as described in https://github.com/Ogeon/rust-on-raspberry-pi, for cross-compiling for the Raspberry Pi sets some environment variables and writes to config files on your host machine. Thus it can be difficult to remember these changes when you want to remove or upgrade the cross compiler or even repeat that process for different versions of rust on the same machine.

alpine - :earth_africa: `alpine` Docker image for multiple architectures

  •    Shell

Multiarch alpine images for Docker. Once you need to configure binfmt-support on your Docker host. This works locally or remotely (i.e using boot2docker or swarm).

xx - Dockerfile cross-compilation helpers

  •    Shell

xx provides tools to support cross-compilation from Dockerfiles that understand the --platform flag passed in from docker build or docker buildx build. These helpers allow you to build multi-platform images from any architecture into any architecture supported by your compiler with native performance. Adding xx to your Dockerfile should only need minimal updates and should not require custom conditions for specific architectures. Cross-compilation can be achieved in Dockerfiles by using multi-stage builds and defining some of the stages to always run on the native architecture used by the builder and execute the cross-compiling compiler. By default, a Dockerfile stage started with FROM keyword default to the target architecture, but this can be overridden with a FROM --platform flag. Using automatic platform ARGs in global scope, the platform of the cross-compiler stage can be set to $BUILDPLATFORM while the value of $TARGETPLATFORM can be passed to the compiler with an environment variable.

We have large collection of open source products. Follow the tags from Tag Cloud >>

Open source products are scattered around the web. Please provide information about the open source projects you own / you use. Add Projects.