• Stars
    star
    153
  • Rank 243,368 (Top 5 %)
  • Language
  • Created about 6 years ago
  • Updated over 3 years ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

Program Analisys and Transformation survey and links (particular focus on SSA)

Program Analysis and Transformation Survey and Links

Table of Contents:

Glossary

  • Critical edge (of a graph) - Edge between a vertex which also has other successors and a vertex which has other predecessors. (wikipedia)
  • DCE - Dead Code Elimination (wikipedia)
  • Graph - (wikipedia)
  • LOLSSA - [ this entry is a joke! due to lolspeak ] a) SSA as defined in some early papers on the matter, especially in the part of out-of-SSA conversion (see epigraph to SSA Deconstruction section below); b) a similar version of SSA used in some (oftentimes amateur) projects decades later.

Names

As a dedication:

We study Program Analysis because it's objective and complex phenomena of nature devoid of subjectivities of the mankind. But then, we can't separate it from the work of great human minds who laid the paths in this area, whose steps we now follow.

These are people who contributed to the Program Analysis field of study (with all the apology to many more who are not listed here). The emphasis here is on well-knownness and public availability of their works:

  • Gregory Chaitin
  • Jeffrey Ullman
  • Alfred Aho
  • Keith Cooper
    • thesis: 1983 "Interprocedural Data Flow Analysis in a Programming Environment"
  • Andrew Appel
    • thesis: 1985 "Compile-time Evaluation and Code Generation in Semantics-Directed Compilers"
    • book 1998: "Modern Compiler Implementation in ML/Java/C"
    • 2000: Optimal Register Coalescing Challenge
  • Preston Briggs
    • thesis: 1992 "Register Allocation via Graph Coloring"
  • Clifford Click @cliffclick
    • thesis: 1995 "Combining Analyses, Combining Optimizations"
  • John Aycock
    • thesis: 2001 "Practical Earley Parsing and the SPARK Toolkit"
    • Hacked on Python compilation: [1], [2], [3], [4]
    • Now hacks on retrogaming: [1], [2]
  • Sebastian Hack
    • thesis: 2006 "Register Allocation for Programs in SSA Form"
  • Matthias Braun @MatzeB
    • thesis: 2006 "Heuristisches Auslagern in einem SSA-basierten Registerzuteiler" in German, "Heuristic spilling in an SSA-based register allocator"
  • Sebastian Buchwald
    • thesis: 2008 "Befehlsauswahl auf expliziten Abhangigkeitsgraphen" in German, "Instruction selection on explicit dependency graphs"
  • Florent Bouchez
    • thesis: 2009 "A Study of Spilling and Coalescing in Register Allocation as Two Separate Phases"
  • Benoit Boissinot
    • thesis: 2010 "Towards an SSA based compiler back-end: some interesting properties of SSA and its extensions"
  • Quentin Colombet
    • thesis 2012: "Decoupled (SSA-based) Register Allocators: from Theory to Practice, Coping with Just-In-Time Compilation and Embedded Processors Constraints"

Intermediate Representation Forms/Types

  • Imperative
  • Functional
    • Static Single-Assignment (SSA) - As argued by Appel, SSA is a functional representation.
    • (Lambda-)Functional
    • Continuation-passing Style (CPS)

SSA Form

Put simple, in an SSA program, each variable is (statically, syntactically) assigned only once.

Wikipedia: https://en.wikipedia.org/wiki/Static_single_assignment_form

General reference: "SSA Book" aka "Static Single Assignment Book" aka "SSA-based Compiler Design" is open, collaborative effort of many SSA researchers to write a definitive reference for all things SSA.

Classification of SSA types

  • Axis 1: Minimality. There're 2 poles: fully minimal vs fully maximal SSA form. Between those, there's continuum of intermediate cases.
    • Fully maximal
      • Defined e.g. by Appel:

        A really crude approach is to split every variable at every basic-block boundary, and put Ο†-functions for every variable in every block.

        Maximal form is the most intuitive form for construction, gives the simplest algorithms for both phi insertion and variable renaming phases of the construction.

    • Optimized maximal
      • An obvious optimization of avoiding placing phi functions in blocks with a single predecessor, as they never needed there. While cuts the number of phi functions, makes renaming algorithm a bit more complex: while for maximal form renaming could process blocks in arbitrary order (because each of program's variables has a local definition in every basic block), optimized maximal form requires processing predecessor first for each such single-predecessor block.
    • Minimal for reducible CFGs
      • Some algorithms (e.g. optimized for simplicity) naturally produce minimal form only for reducible CFGs. Applied to non-reducible CFGs, they may generate extra Phi functions. There're usually extensions to such algorithms to generate minimal form even for non-reducible CFGs too (but such extensions may add noticeable complexity to otherwise "simple" algorithm). Examplem of such an algorithm ins 2013 Braun et al.
    • Fully minimal
      • This is usually what's sought for SSA form, where there're no superflous phi functions, based only on graph properties of the CFG (with consulting semantics of the underlying program).
  • Axis 2: Prunedness. As argued (implied) by 2013 Braun et al., prunedness is a separate trait from minimality. E.g., their algorithm constructs not fully minimal, yet pruned form. Between pruned and non-pruned forms, there're intermediate types again.
    • Pruned
      • Minimal form can still have dead phi functions, i.e. phi functions which reference variables which are not actually used in the rest of the program. Note that such references are problematic, as they artificially extend live ranges of referenced variables. Likewise, it defines new variables which aren't really live. The pruned SSA form is devoid of the dead phi functions. Two obvious way to achieve this: a) perform live variable analysis prior to SSA construction and use it to avoid placing dead phi functions; b) run dead code elimination (DCE) pass after the construction (which requires live variable analysis first, this time on SSA form of the program already). Due to these additional passes, pruned SSA construction is more expensive than just the minimal form. Note that if we intend to run DCE pass on the program anyway, which is often happens, we don't really need to be concerned to construct pruned form, as we will get it after the DCE pass "for free". Except of course that minimal and especially maximal form require more space to store and more time to go thru it during DCE.
    • Semi-pruned
      • Sometimes called "Briggs-Minimal" form. A compromise between fully pruned and minimal form. From Wikipedia:

        Semi-pruned SSA form[6] is an attempt to reduce the number of Ξ¦ functions without incurring the relatively high cost of computing live variable information. It is based on the following observation: if a variable is never live upon entry into a basic block, it never needs a Ξ¦ function. During SSA construction, Ξ¦ functions for any "block-local" variables are omitted.

    • Not pruned
  • Axis 2: Conventional vs Transformed SSA
    • Conventional
      • Allows for easy deconstruction algorithm (literally, just drop SSA variables subscripts and remove Phi functions). Usually, after construction, SSA is in conventional form (if during construction, additional optimizations were not performed).
    • Transformed
      • Some optimizations applied to an SSA program make simple deconstruction algorithm outlined above not possible (not producing correct results). This is known as "transformed SSA". There're algorithms to convert transformed SSA into conventional form.
  • Axis 3: Strict vs non-strict SSA
    • Non-strict SSA allows some variables to be undefined on some paths (just like conventional imperative programs).
    • Strict form requires each use to be dominated by definition. This in turn means that every variable must be explicitly initialized. Non-strict program can be trivially converted into strict form, by initializing variables with special values, like "undef" for truly undefined values, "param" for function paramters, etc. Most of SSA algorithms requires/assume strict SSA form, so non-strict is not further considered.

Discussion: There's one and true SSA type - the maximal one. It has a straightforward, easy to understand construction algorithm which does not depend on any other special algorithms. Running a generic DCE algorithm on it will remove any redundancies of the maximal form (oftentimes, together with other dead code). All other types are optimizations of the maximal form, allowing to generate less Phi functions, so less are removed later. Optimizations are useful, but the usual warning about premature optimization applies.

History

  • 1969

According to Aycock/Horspool:

The genesis of SSA form was in the 1960s with the work of Shapiro and Saint [23,19]. Their conversion algorithm was based upon finding equivalence classes of variables by walking the control-flow graph.

R. M. Shapiro and H. Saint. The Representation of Algorithms. Rome Air Development Center TR-69-313, Volume II, September 1969.

Given the possibility of concurrent operation, we might also wish to question the automatic one-one mapping of variable names to equipment locations. Two uses of the same variable name might be entirely unrelated in terms of data dependency and thus potentially concurrent if mapped to different equipment locations.

Continues on the p.31 of the paper (p.39 of the PDF) under the title:

VI. Variable-Names and Data Dependency Relations

  • 1988

Then, following Wikipedia, "SSA was proposed by Barry K. Rosen, Mark N. Wegman, and F. Kenneth Zadeck in 1988." Barry Rosen; Mark N. Wegman; F. Kenneth Zadeck (1988). "Global value numbers and redundant computations"

Construction Algorithms

Based on excerpts from "Simple Generation of Static Single-Assignment Form", Aycock/Horspool

For Reducible CFGs (i.e. special case)

  • 1986 R. Cytron, A. Lowry, K. Zadeck. Code Motion of Control Structures in High-Level Languages. Proceedings of the Thirteenth Annual ACM Symposium on Principles of Programming Languages, 1986, pp. 70–85.

    Cytron, Lowry, and Zadeck [11] predate the use of Ο†-functions, and employ a heuristic placement policy based on the interval structure of the control-flow graph, similar to that of Rosen, Wegman, and Zadeck [22]. The latter work is interesting because they look for the same patterns as our algorithm does during our minimization phase. However, they do so after generating SSA form, and then only to correct β€˜second order effects’ created during redundancy elimination.

  • 1994 Single-Pass Generation of Static Single-Assignment Form for Structured Languages, Brandis and MΓΆssenbΓΆck

    Brandis and MΓΆssenbΓΆck [5] generate SSA form in one pass for structured control- flow graphs, a subset of reducible control-flow graphs, by delicate placement of Ο†-functions. They describe how to extend their method to reducible control-flow graphs, but require the dominator tree to do so.

  • 2000 Simple Generation of Static Single-Assignment Form, 2000, John Aycock and Nigel Horspool

    In this paper we present a new, simple method for converting to SSA form, which produces correct solutions for nonreducible control-flow graphs, and produces minimal solutions for reducible ones.

For Non-Reducible CFGs (i.e. general case)

  • 1991 R. Cytron, J. Ferrante, B. K. Rosen, M. N. Wegman, and F. K. Zadeck. Efficiently Computing Static Single-Assignment Form and the Control Dependence Graph. ACM TOPLAS 13, 4 (October 1991), pp. 451–490.

    "Canonical" SSA construction algorithm.

    • 1995 R. K. Cytron and J. Ferrante. Efficiently Computing Ο†-Nodes On-The-Fly. ACM TOPLAS 17, 3 (May 1995), pp. 487–506.

      Cytron and Ferrante [9] later refined their method so that it runs in almost-linear time.

  • 1994 R. Johnson, D. Pearson, and K. Pingali. The Program Structure Tree: Computing Control Regions in Linear Time. ACM PLDI ’94, pp. 171–185.

    Johnson, Pearson, and Pingali [16] demonstrate conversion to SSA form as an application of their β€œprogram structure tree,” a decomposition of the control- flow graph into single-entry, single-exit regions. They claim that using this graph representation allows them to avoid areas in the control-flow graph that do not contribute to a solution.

  • 1995 V. C. Sreedhar and G. R. Gao. A Linear Time Algorithm for Placing Ο†-Nodes. Proceedings of the Twenty-Second Annual ACM Symposium on Principles of Programming Languages, 1995, pp. 62–73.

    Sreedhar and Gao [24] devised a linear-time algorithm for Ο†-function placement using DJ-graphs, a data structure which combines the dominator tree with information about where data flow in the program merges.

  • 2013 M. Braun, S. Buchwald, S. Hack, R. Leißa, C. Mallon, and A. Zwinkau. Simple and efficient construction of static single assignment form. In R. Jhala and K. Bosschere, editors, Compiler Construction, volume 7791 of Lecture Notes in Computer Science, pp. 102–122. Springer, 2013. doi: 10.1007/978-3-642-37051-9_6.

    Braun, et al present a simple SSA construction algorithm, which allows direct translation from an abstract syntax tree or bytecode into an SSA-based intermediate representation. The algorithm requires no prior analysis and ensures that even during construction the intermediate representation is in SSA form. This allows the application of SSA-based optimizations during construction. After completion, the intermediate representation is in minimal and pruned SSA form. In spite of its simplicity, the runtime of the algorithm is on par with Cytron et al.’s algorithm.

    • 2016 Verified Construction of Static Single Assignment Form, Sebastian Buchwald, Denis Lohner, Sebastian Ullrich

Deconstruction Algorithms


Epigraph (due to Boissinot, slide 20):

Naively, a k-input Phi-function at entrance to a node X can be replaced by k ordinary assignments, one at the end of each control flow predecessor of X. This is always correct...

-- Cytron, Ferrante, Rosen, Wegman, Zadeck (1991) Efficiently computing static single assignment form and the control dependence graph.

Cytron et al. (1991): Copies in predecessor basic blocks.

Incorrect!

  • Bad understanding of parallel copies
  • Bad understanding of critical edges and interference

Briggs et al. (1998)

Both problems identified. General correctness unclear.

Sreedhar et al. (1999)

Correct but:

  • handling of complex branching instructions unclear
  • interplay with coalescing unclear
  • "virtualization" hard to implement

Many SSA optimizations turned off in gcc and Jikes.


TBD. Some papers in the "Construction Algorithms" section also include information/algorithms on deconstruction.

Converting out of SSA is effectively elimination (lowering) of Phi functions. (Note that Phi functions may appear in a program which is not (purely) SSA, so Phi elimination is formally more general process than conversion out of SSA.)

There are 2 general ways to eliminate Phi functions:

  1. Requires splitting critical edges, but doesn't introduce new variables and extra copies: Treat Phi functions as parallel copies on the incoming edges. This requires splitting critical edges. Afterwards, parallel copies are sequentialized.
  2. Does not require splitting critical edges, but introduces new variables and extra copies to them which then would need to be coalesced: For Conventional SSA (CSSA), result and arguments of a Phi can be just renamed to the same name (throughout the program), and the Phi removed. This is because arguments and result do not interfere among themselves (CSSA is produced by normal SSA construction algorithms, which don't perform copy propagation and value numbering during construction). Arbitrary SSA (or Transformed SSA, TSSA) can be converted to CSSA by splitting live ranges of Phi arguments and results, by renaming them to new variables, then inserting parallel copy of old argument variables to new at the end of each predecessor, and parallel copy of all Phi results, after all the Phi functions of the current basic block. These parallel copies (usually) can be sequentialized trivially (so oftentimes even not treated as parallel in the literature). This method does not require splitting critical edges, but introduces many unnecessary copies (intuitively, for non-interfering Phi variables), which then need to be optimized by coalescing (or alternatively, unneeded copies should not be introduced in the first place).

Control Flow Analysis

According to 1997 Muchnick:

  • Analysis on "raw" graphs, using dominators, the iterative dataflow algorithms
  • Interval Analysis, which then allows to use adhoc optimized dataflow analysis. Variants in the order of advanceness:
    • The simplest form is T1-T2 reduction
    • Maximal intervals analysis
    • Minimal intervals analysis
    • Structural analysis

Alias Analysis

Register Allocation

Wikipedia: https://en.wikipedia.org/wiki/Register_allocation

Terms:

  • Decoupled allocator - In classic register allocation algorithms, variables assignment to registers and spilling of non-assignable variables are tightly-coupled, interleaving phases of the single algorithm. In a decoupled allocator, these phases are well separated, with spilling algorithm first selecting and rewriting spilling variables, and assignment algorithm then dealing with the remaining variables. Most of decoupled register allocators are SSA-based, though recent developments also include decoupled allocators for standard imperative programs.
  • Chordal graph - A type of graph, having a property that it can be colored in polynomial time (whereas generic graphs require NP time for coloring). Interference graphs of SSA programs are chordal. (Note that arbitrary pre-coloring and/or register aliasing support for chordal graphs, as required for real-world register allocation, may push complexity back into NP territory).

Conventional Register Allocation

TBD

Register Allocation on SSA Form

Projects

Academic projects


This list is compiled and maintained by Paul Sokolovsky, and released under Creative Commons Attribution-ShareAlike 4.0 International License (CC BY-SA 4.0).

More Repositories

1

esp-open-sdk

Free and open (as much as possible) integrated SDK for ESP8266/ESP8285 chips
Makefile
1,971
star
2

picotui

Lightweight, pure-Python Text User Interface (TUI) widget toolkit with minimal dependencies. Dedicated to the Pycopy project.
Python
808
star
3

pycopy

Pycopy - a minimalist and memory-efficient Python dialect. Good for desktop, cloud, constrained systems, microcontrollers, and just everything.
C
764
star
4

awesome-smarthome

Curated list of awesome SmartHome/Home Automation things (open and leaving users in control)
487
star
5

picoweb

Really minimal web application framework for the Pycopy project (minimalist Python dialect) and its "uasyncio" async framework
Python
474
star
6

ScratchABit

Easily retargetable and hackable interactive disassembler with IDAPython-compatible plugin API
Python
392
star
7

uzlib

Radically unbloated DEFLATE/zlib/gzip compression/decompression library. Can decompress any gzip/zlib data, and offers simplified compressor which produces gzip-compatible output, while requiring much less resources (and providing less compression ratio of course).
C
303
star
8

pycopy-lib

Standard library of the Pycopy project, minimalist and light-weight Python language implementation
Python
247
star
9

awesome-micropython

Curated list of awesome MicroPython resources
175
star
10

blutunode

Autonomous wireless sensor/actuator node using bluetooth modules based on CSR BlueCore chipset. See wiki for more info.
C
149
star
11

foreign-dlopen

Small library allowing to use dlopen() from statically-linked applications (where statically-linked executable vs loaded shared library may use completely different libc's)
C
143
star
12

awesome-linux-android-hacking

List of hints and Q&As to get most of your Linux/Android device
127
star
13

ssabook

Mirror of InriaForge SSABook repository: https://gforge.inria.fr/projects/ssabook/ (was scheduled for retirement at the end of 2020, was still online as of 2021-03, but then gone by 2021-09).
TeX
125
star
14

yaota8266

Yet another OTA solution for ESP8266, this time supporting large (>512KB) firmwares even on 1MB devices (repo is rebased)
C
119
star
15

ScratchABlock

Yet another crippled decompiler project
Python
103
star
16

awesome-python-compilers

Retrospective of Python compilation efforts
62
star
17

utemplate

Micro template engine in Python with low memory usage, designed for Pycopy, a minimalist Python dialect, but also compatible with other Pythons.
Python
60
star
18

graph-llvm-ir

Visualization of LLVM IR
Python
55
star
19

PeripheralTemplateLibrary

Cross-platform, cross-MCU C++ template library for microcontrollers and peripheral devices
C++
54
star
20

android-platform-headers

Collection of platform headers and link libs for all versions of Android. (repo is rebased, see wiki)
C
54
star
21

visited_places

Simple, static, local visited places map (aka travel map) using D3 and D3 Datamaps
HTML
49
star
22

re1.5

re1, the unbloated regexp engine by Russ Cox, elaborated to be useful for real-world applications
C
41
star
23

python-compiler.old

Python2 compiler package ported to Python3. Compiles Python AST (as produced by the "ast" module) to bytecode assembly and code objects.
Python
41
star
24

python-imphook

Simple and clear import hooks for Python - import anything as if it were a Python module
Python
36
star
25

optware-android

Optware setup script for Android devices. Not actively maintained any more. You may want to look at https://github.com/Entware-ng/Entware-ng/wiki/Install-on-Android
Shell
35
star
26

notes-pico

Flask Notes sample application ported to the Pycopy's picoweb web micro-framework
Python
35
star
27

ida-xtensa2

IDAPython plugin for Tensilica Xtensa (as seen in ESP8266), version 2
Python
34
star
28

cortex-uni-startup

Unified startup code and link scripts for Cortex-M microcontrollers
C
32
star
29

pyflate

Pure Python zlib/gzip/bzip2 decompessor/bitstream dumper, plus additional utilities
Python
28
star
30

berkeley-db-1.xx

Berkeley DB 1.85 with patches and fixes applied
C
24
star
31

awesome-implicit-data-structures

Awesome implicit data structures
23
star
32

xtensa-subjects

Xtensa CPU architecture (ESP8266) binaries for ScratchABit interactive disassembler
HTML
22
star
33

esp-open-lwip

Superseded by https://github.com/pfalcon/lwip-esp8266. Was: Untangled build of vendor ESP8266 lwIP library
C
22
star
34

pymsasid3

Pure-Python x86 disassembler, ported to modern Python, with bugfixes
Python
21
star
35

lwip-esp8266

Upstream lwIP with complete history and cleaned up ESP8266 patchset on top
C
18
star
36

idapython

Automatically exported from code.google.com/p/idapython
Python
18
star
37

libperipha

Grand unified collection of headers to access various hardware chips and components
C
18
star
38

pyedit

Simple text editor widget for Python and Pycopy. Further developed in https://github.com/pfalcon/picotui
Python
18
star
39

squirrel-modules

General-purpose Squirrel language project. Includes collection of basic modules (including module loading infrastructure)
C++
17
star
40

pycopy-serial

pySerial-like interface for Pycopy (unix port)
Python
15
star
41

pyastinterp

Python AST interpreter (aka tree-walking interpreter) in Python. Aka meta-circular interpreter.
Python
15
star
42

opkg-static

Static self-contained opkg (the package manager) build for real-world embedded platforms like Android, Kindle, etc.
Shell
14
star
43

awesome-virtual-machines

Awesome Virtual Machines (VMs) and Language Runtimes (awesome from Computer Science perspective)
14
star
44

uorm

Sqlite3-based anti-ORM for Pycopy
Python
14
star
45

ctopy

Hacking on ESR's ctopy the C to Python conversion tool: http://www.catb.org/~esr/ctopy/
Python
14
star
46

papersman

Minimalist electronic documents/papers/publications manager/indexer/categorizer
Python
14
star
47

android-native

Android native (command-line) examples, utils and tools. See Wiki for more info.
C++
13
star
48

uart-bitbang

UART protocol for MCU using GPIO bitbang. Rate-adaptive and requires only clock counter to operate.
C
13
star
49

beap

Beap (bi-parental heap) algorithm reference implementation in Python
Python
13
star
50

esp-docs

Helping Espressif Systems, Inc. achieve 12-year product longevity (mirror of ESP8266, etc. documentation)
12
star
51

pycopy-projs

Various Pycopy-related proofs of concepts and hacks which don't deserve dedicated repos
Python
11
star
52

canterbury-corpus

The Canterbury compression corpus as a git repository
HTML
10
star
53

ullvm_c

Lightweight LLVM C API bindings for Pycopy and other Python implementations
Python
10
star
54

apps2org

Label/tag based application organizer and launcher for Android, fork of https://code.google.com/p/appsorganizer
Java
10
star
55

aes256_128

Code size efficient AES256/AES128 implementation
C
10
star
56

pycopy-jitgen

Generating machine code at runtime (aka JIT) using Pycopy (small Python dialect)
Python
10
star
57

uremi

Proof of concept of developing alike of https://github.com/dddomodossola/remi for Pycopy
Python
9
star
58

ppxml2db

Scripts to import PortfolioPerformance (https://github.com/portfolio-performance/portfolio) XML into a SQLite DB and export back
Python
9
star
59

sphinx_selective_exclude

Sphinx extension (plugin) to make ".only::" directive work like you expect. (Plus some other goodies for selective indexes.) [Unmaintained, may no longer work with latest Sphinx versions.]
Python
9
star
60

esp8266-re-wiki-mirror

Mirror of http://esp8266-re.foogod.com/wiki/
8
star
61

pycopy-filedb

Simple file-based ORM for Pycopy
Python
8
star
62

Chsmartbulb-led-bulb-speaker

Hacking "Chsmartbulb" BT/BLE LED bulb speaker
Python
8
star
63

llvm-codegen-py

(Machine) code generation experiments in Python, roughly centered around LLVM IR
Python
7
star
64

pymapfile

Python module to parse GNU ld/gcc map files
Python
7
star
65

arduino-hosted

Arduino Hosted Python module, allows to rapid-prototype simple Arduino microcontroller applications on desktop computer. Unlike many other Python wrappers, this provides syntax as close as possible to Arduino.
Python
7
star
66

pycopy-btreedb

Very simple ORM for Pycopy's btree module
Python
6
star
67

axtls

Pycopy fork of axTLS
C
6
star
68

pycopy-ffigen

FFI bindings generator for Pycopy
Python
6
star
69

simplejtag

Protocol and firmware to turn any low-cost board into JTAG/SWD adapater to use wiyh OpenOCD, PySWD, etc.
C++
6
star
70

picompile

Pico Compile, factored out "numpile" project, a small JIT compiler for Python with type inference
Python
6
star
71

android-depends

Tool to analyze Android module dependencies. Forked from http://code.google.com/p/rxwen-blog-stuff/source/browse/trunk/tools/
Python
6
star
72

awesome-python-projects

List of Python projects which either do something non-trivial, or are unbloated and lightweight. (See wiki)
6
star
73

parcopy

Implementation (in Python) of algorithm(s) for sequentializing of parallel copy
Python
6
star
74

udownmark

A dead simple parser/renderer for Markdown-like text markup (subset of Markdown). Dedicated to Pycopy, a minimalist Python implementation (https://github.com/pfalcon/micropython).
Python
5
star
75

change-control-manifesto

Change Control Manifesto for principled Open Source projects
5
star
76

esp-sdk-tools

Tools for hacking on Espressif ESP8266/ESP32 SDKs
Shell
4
star
77

py-runinpkg

Run Python scripts inside package directory as normal files, even if they use relative imports
Python
3
star
78

pseudoc-ir

Like LLVM, but simpler
Python
3
star
79

awesome-consumer-iot-hacks

A Collection of Hacks in Consumer IoT Space so that we can use those products (hopefully).
3
star
80

aygshell-win32

Implementation of WinCE AYGSHELL functions for pure Win32 API
C
3
star
81

ARM-CMSIS-BSD

BSD-licensed CMSIS core implementation from ARM, imported from CMSIS-SP-00300-r3p2-00rel1.zip
C
3
star
82

b43-tools

Mirror of git://git.bues.ch/b43-tools.git "Tools for the Broadcom 43xx series WLAN chip"
C
3
star
83

pycopy-uffmpeg

Pycopy bindings for FFmpeg
Python
3
star
84

cppmicroweb

Proof of concept C++ web micro framework for constrained devices inspired by Python microframeworks
C++
3
star
85

pycopy-dlman

Very simple download manager based on wget and Pycopy
Python
2
star
86

uaio_xiaomi_gw

Pycopy uasyncio module for Xiaomi Mi Home Gateway
Python
2
star
87

optware

Mirror of NSLU2 Optware + updates
C
2
star
88

openwrt-tools

Tools to automatically install/configure/manage OpenWRT
Shell
2
star
89

esp-open-headers

Headers for ESP8266 SDK internal functions and structures
C
2
star
90

awesome-stuff

Projects I'd like to record somewhere
2
star
91

dotfiles

Personal dotfiles
Shell
2
star
92

py-simple-serial

Very simple Python serial port module for Linux, roughly compatible with PySerial
Python
2
star
93

pycopy-libusb

libusb bindings for Pycopy
Python
2
star
94

b43-ucode

Mirror of git://git.bues.ch/b43-ucode.git "OpenSource firmware for Broadcom 43xx devices"
Assembly
2
star
95

meta-prefixdistro

OpenEmbedded layer for simlified distro rooted at atbitrary filesystem prefix
1
star
96

python-simple-mixin

Simple mixins for Python without multiple inheritance
Python
1
star
97

git-pynex

Proof of concept reimplementation of subset of git-annex in Python
Python
1
star
98

osmand-gpx-vis

Visualizing GPX tracks recorded by Osmand Android navigation software and other tools
Python
1
star
99

snapdragon410-mmio-gpio

Memory-mapped GPIO access on Snapdragon 410 SoC using MicroPython (and CPython)
Python
1
star
100

fdroidclient

Mirror (+local dev) of client app for F-Droid, FOSS Android package repository.
Java
1
star