tuupola / hagl Goto Github PK

View Code? Open in Web Editor NEW

284.0 14.0 46.0 285 KB

Hardware Agnostic Graphics Library for embedded

Home Page: https://www.appelsiini.net/tags/hagl/

License: MIT License

Makefile 0.02% C 99.47% CMake 0.50%

graphics-library gd32v rp2040 esp32 raspberry-pi-pico esp-idf hagl

hagl's Introduction

Hardware Agnostic Graphics Library

HAGL is a lightweight hardware agnostics graphics library. It supports basic geometric primitives, bitmaps, blitting, fixed width fonts. Library tries to stay lightweight but targets reasonably powerful microchips such as ESP32. There is no dynamic allocation.

This can still be considered work in progress. API should be 90% stable.

Backend

To use HAGL you must provide a backend. The backend must provide atleast a function for putting a pixel. If nothing else is provided all higher level graphical functions will use this function to draw the primitives. While proper documentation is lacking see the example backend implementations for GD, SDL2, ESP-IDF (Ilitek, Sitronix, Galaxycore), ESP-IDF (Solomon), Nuclei RISC-V SDK, Raspberry Pi Pico SDK and Raspberry Pi Pico VGA board.

Usage

High level functions are pretty self explanatory. For example applications see Pico Effects, ESP Effects, SDL2 Effects, ESP GFX, and GD32V Effects.

Lifecycle

Before you start drawing you should call hagl_init(). Some HAL configurations require you to call hagl_flush() to update the contents of the screen. Before exiting your program it is good idea to call hagl_close()to clean things up.

#include <hagl_hal.h>
#include <hagl.h>

hagl_backend_t *display = hagl_init();

/* Main loop. */
while (1) {
    hagl_clear(display);
    hagl_load_image(display, 0, 0, "/sdcard/hello.jpg");
    hagl_flush(display);
};

hagl_close(display);

Colors

HAL defines what kind of pixel format is used. Most common is RGB565 which is represented by two bytes. If you are sure you will be using only RGB565 colors you could use the following shortcut to create a random color.

hagl_color_t color = rand() % 0xffff;

To write portable code which can be run with different pixel formats use the following instead.

uint8_t r = rand() % 255;
uint8_t g = rand() % 255;
uint8_t b = rand() % 255;
hagl_color_t color = hagl_color(display, r, g, b);

Put a pixel

for (uint32_t i = 1; i < 100000; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    hagl_color_t color = rand() % 0xffff;

    hagl_put_pixel(display, x0, y0, color);
}

Get a pixel

int16_t x0 = rand() % display->width;
int16_t y0 = rand() % display->height;

hagl_color_t pixel = hagl_get_pixel(display, x0, y0);

Note that if requesting coordinates outside the clip window color black is returned. This behaviour is unoptimal and might change in the future.

Draw a line

for (uint16_t i = 1; i < 1000; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    int16_t x1 = rand() % display->width;
    int16_t y1 = rand() % display->height;
    hagl_color_t color = rand() % 0xffff;

    hagl_draw_line(display, x0, y0, x1, y1, color);
}

Draw a horizontal line

for (uint16_t i = 1; i < 1000; i++) {
    int16_t x0 = rand() % (display->width / 2);
    int16_t y0 = rand() % display->height;
    int16_t x1 = rand() % (display->width / 2);
    int16_t width = rand() % (display->width - x0);
    hagl_color_t color = rand() % 0xffff;

    /* First two are aliases. */
    hagl_draw_hline(display, x0, y0, width, color);
    hagl_draw_hline_xyw(display, x0, y0, width, color);

    hagl_draw_hline_xyx(display, x0, y0, x1, color);
}

Draw a vertical line

for (uint16_t i = 1; i < 1000; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % (display->height / 2);
    int16_t y1 = rand() % (display->height / 2);
    int16_t height = rand() % (display->height - y0);
    hagl_color_t color = rand() % 0xffff;

    /* First two are aliases. */
    hagl_draw_vline(display, x0, y0, height, color);
    hagl_draw_vline_xyh(display, x0, y0, height, color);

    hagl_draw_vline_xyy(display, x0, y0, y1, color);
}

Draw a circle

for (uint16_t i = 1; i < 500; i++) {
    int16_t x0 = display->width / 2;
    int16_t y0 = display->height / 2;
    int16_t radius = rand() % display->width;
    hagl_color_t color = rand() % 0xffff;

    hagl_draw_circle(display, x0, y0, radius, color);
}

Draw a filled circle

for (uint16_t i = 1; i < 500; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    int16_t radius = rand() % 100;
    hagl_color_t color = rand() % 0xffff;

    hagl_fill_circle(display, x0, y0, radius, color);
}

Draw an ellipse

for (uint16_t i = 1; i < 500; i++) {
    int16_t x0 = display->width / 2;
    int16_t y0 = display->height / 2;
    int16_t rx = rand() % display->width;
    int16_t ry = rand() % display->height;
    hagl_color_t color = rand() % 0xffff;

    hagl_draw_ellipse(display, x0, y0, rx, ry, color);
}

Draw a filled ellipse

for (uint16_t i = 1; i < 500; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    int16_t rx = rand() % display->width / 4;
    int16_t ry = rand() % display->height / 4;
    hagl_color_t color = rand() % 0xffff;

    hagl_fill_ellipse(display, x0, y0, rx, ry, color);
}

Draw a triangle

int16_t x0 = rand() % display->width;
int16_t y0 = rand() % display->height;
int16_t x1 = rand() % display->width;
int16_t y1 = rand() % display->height;
int16_t x2 = rand() % display->width;
int16_t y2 = rand() % display->height;
hagl_color_t color = rand() % 0xffff;

hagl_draw_triangle(display, x0, y0, x1, y1, x2, y2, color);

Draw a filled triangle

int16_t x0 = rand() % display->width;
int16_t y0 = rand() % display->height;
int16_t x1 = rand() % display->width;
int16_t y1 = rand() % display->height;
int16_t x2 = rand() % display->width;
int16_t y2 = rand() % display->height;
hagl_color_t color = rand() % 0xffff;

hagl_fill_triangle(display, x0, y0, x1, y1, x2, y2, color);

Draw a rectangle

for (uint16_t i = 1; i < 50; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    int16_t x1 = rand() % display->width;
    int16_t y1 = rand() % display->height;
    int16_t w = rand() % display->width / 2;
    int16_t h = rand() % display->height / 2;
    hagl_color_t color = rand() % 0xffff;

    /* First two are aliases. */
    hagl_draw_rectangle(display, x0, y0, x1, y1, color);
    hagl_draw_rectangle_xyxy(display, x0, y0, x1, y1, color);

    hagl_draw_rectangle_xywh(display, x0, y0, w, h, color);
}

Draw a filled rectangle

for (uint16_t i = 1; i < 10; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    int16_t x1 = rand() % display->width;
    int16_t y1 = rand() % display->height;
    int16_t w = rand() % display->width / 2;
    int16_t h = rand() % display->height / 2;
    hagl_color_t color = rand() % 0xffff;

    /* First two are aliases. */
    hagl_fill_rectangle(display, x0, y0, x1, y1, color);
    hagl_fill_rectangle_xyxy(display, x0, y0, x1, y1, color);

    hagl_fill_rectangle_xywh(display, x0, y0, w, h, color);
}

Draw a rounded rectangle

for (uint16_t i = 1; i < 30; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    int16_t x1 = rand() % display->width;
    int16_t y1 = rand() % display->height;
    int16_t w = rand() % display->width / 2;
    int16_t h = rand() % display->height / 2;
    int16_t r = 10
    hagl_color_t color = rand() % 0xffff;

    /* First two are aliases. */
    hagl_draw_rounded_rectangle(display, x0, y0, x1, y1, r, color);
    hagl_draw_rounded_rectangle_xyxy(display, x0, y0, x1, y1, r, color);

    hagl_draw_rounded_rectangle_xywh(display, x0, y0, w, h, r, color);
}

Draw a filled rounded rectangle

for (uint16_t i = 1; i < 30; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    int16_t x1 = rand() % display->width;
    int16_t y1 = rand() % display->height;
    int16_t w = rand() % display->width / 2;
    int16_t h = rand() % display->height / 2;
    int16_t r = 10
    hagl_color_t color = rand() % 0xffff;

    /* First two are aliases. */
    hagl_fill_rounded_rectangle(display, x0, y0, x1, y1, r, color);
    hagl_fill_rounded_rectangle_xyxy(display, x0, y0, x1, y1, r, color);

    hagl_fill_rounded_rectangle_xyxy(display, x0, y0, w, h, r, color);
}

Draw a polygon

You can draw polygons with unlimited number of vertices which are passed as an array. Pass the number of vertices as the first argument.

int16_t x0 = rand() % display->width;
int16_t y0 = rand() % display->height;
int16_t x1 = rand() % display->width;
int16_t y1 = rand() % display->height;
int16_t x2 = rand() % display->width;
int16_t y2 = rand() % display->height;
int16_t x3 = rand() % display->width;
int16_t y3 = rand() % display->height;
int16_t x4 = rand() % display->width;
int16_t y4 = rand() % display->height;
hagl_color_t color = rand() % 0xffff;
int16_t vertices[10] = {x0, y0, x1, y1, x2, y2, x3, y3, x4, y4};

hagl_draw_polygon(display, 5, vertices, color);

Draw a filled polygon

You can draw filled polygons with up to 64 vertices which are passed as an array. First argument is the number of vertices. Polygon does not have to be concave.

int16_t x0 = rand() % display->width;
int16_t y0 = rand() % display->height;
int16_t x1 = rand() % display->width;
int16_t y1 = rand() % display->height;
int16_t x2 = rand() % display->width;
int16_t y2 = rand() % display->height;
int16_t x3 = rand() % display->width;
int16_t y3 = rand() % display->height;
int16_t x4 = rand() % display->width;
int16_t y4 = rand() % display->height;
hagl_color_t color = rand() % 0xffff;
int16_t vertices[10] = {x0, y0, x1, y1, x2, y2, x3, y3, x4, y4};

hagl_fill_polygon(display, 5, vertices, color);

Put a single char

The library supports Unicode fonts in fontx format. It only includes three fonts by default. You can find more at tuupola/embedded-fonts and CHiPs44/fontx2-fonts repositories.

for (uint16_t i = 1; i < 10000; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    hagl_color_t color = rand() % 0xffff;
    char code = rand() % 255;

    hagl_put_char(display, code, x0, y0, color, font8x8);
}

Put a string

The library supports Unicode fonts in fontx format. It only includes three fonts by default. You can find more at tuupola/embedded-fonts repository.

for (uint16_t i = 1; i < 10000; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    hagl_color_t color = rand() % 0xffff;

    hagl_put_text(display, u"YO! MTV raps.", x0, y0, color, font6x9);
}

Blit a bitmap

Blit copies a bitmap to the screen. This example uses a glyph bitmap which is extracted from a font.

hagl_bitmap_t bitmap;
bitmap.buffer = (uint8_t *) malloc(6 * 9 * sizeof(hagl_color_t));

for (uint16_t i = 1; i < 20000; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    hagl_color_t color = rand() % 0xffff;
    uint16_t code = rand() % 0xffff;
    hagl_get_glyph(display, code, color, &bitmap, font6x9);

    /* These two are aliases. */
    hagl_blit(display, x0, y0, &bitmap);
    hagl_blit_xy(display, x0, y0, &bitmap);
}

Blit a bitmap scaled up or down

Scale blit copies and scales a bitmap to the surface. This example uses a glyph bitmap which is extracted from a font.

hagl_bitmap_t bitmap;
bitmap.buffer = (uint8_t *) malloc(6 * 9 * sizeof(hagl_color_t));

for (uint16_t i = 1; i < 20000; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    hagl_color_t color = rand() % 0xffff;
    uint16_t code = rand() % 0xffff;
    hagl_get_glyph(display, code, color, &bitmap, font6x9);

    /* These two examples do the same thing. */
    hagl_blit_xywh(display, x0, y0, 24, 36, &bitmap);
    hagl_blit_xyxy(display, x0, y0, x0 + 23, y0 + 35, &bitmap);
}

Clip window

You can restrict the area of drawing by setting a clip window.

hagl_set_clip(display, 0, 40, display->width, display->height - 40);

for (uint16_t i = 1; i < 500; i++) {
    int16_t x0 = rand() % display->width;
    int16_t y0 = rand() % display->height;
    int16_t radius = rand() % 100;
    hagl_color_t color = rand() % 0xffff;

    hagl_fill_circle(display, x0, y0, radius, color);
}

License

The MIT License (MIT). Please see License File for more information.

hagl's People

Contributors

Stargazers

Watchers

hagl's Issues

is it possible to use HAGL with platformio and arduino framework?

Hello.
Is it possible to use this library with ESP32 (TTGO TDISPLAY, buildin screen not used, attached DFR0665 screen) + platformio + arduino framework? I never used kconfig, makefile and stuff like that so im not sure how to prepare it.

here is my current attempt but can not compile it
https://github.com/smarq8/ESP32_arduino_platformIO_HAGL

main.cpp

#include <Arduino.h>
#include <hagl_hal.h>
#include <hagl.h>


void setup(){
    hagl_init();
}

void loop(){
    hagl_clear_screen();
    // some drawing stuff
    hagl_flush();
    delay(500);
}

platformio.ini

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino

> Executing task: C:\Users\xXx\.platformio\penv\Scripts\platformio.exe run --environment esp32dev <

Processing esp32dev (platform: espressif32; board: esp32dev; framework: arduino)
--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Verbose mode can be enabled via `-v, --verbose` option
CONFIGURATION: https://docs.platformio.org/page/boards/espressif32/esp32dev.html
PLATFORM: Espressif 32 (3.3.2) > Espressif ESP32 Dev Module
HARDWARE: ESP32 240MHz, 320KB RAM, 4MB Flash
DEBUG: Current (esp-prog) External (esp-prog, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa)
PACKAGES:
 - framework-arduinoespressif32 3.10006.210326 (1.0.6)
 - tool-esptoolpy 1.30100.210531 (3.1.0)
 - toolchain-xtensa32 2.50200.97 (5.2.0)
LDF: Library Dependency Finder -> http://bit.ly/configure-pio-ldf
LDF Modes: Finder ~ chain, Compatibility ~ soft
Found 29 compatible libraries
Scanning dependencies...
Dependency Graph
|-- <hagl>
Building in release mode
Compiling .pio\build\esp32dev\src\main.cpp.o
Compiling .pio\build\esp32dev\lib3a2\hagl\hagl.c.o
In file included from lib\hagl\src\hagl.c:49:0:
lib\hagl\include/hagl.h:45:22: fatal error: hagl_hal.h: No such file or directory

******************************************************************
* Looking for hagl_hal.h dependency? Check our library registry!
*
* CLI  > platformio lib search "header:hagl_hal.h"
* Web  > https://platformio.org/lib/search?query=header:hagl_hal.h
*
******************************************************************

compilation terminated.
src\main.cpp:2:22: fatal error: hagl_hal.h: No such file or directory

******************************************************************
* Looking for hagl_hal.h dependency? Check our library registry!
*
* CLI  > platformio lib search "header:hagl_hal.h"
* Web  > https://platformio.org/lib/search?query=header:hagl_hal.h
*
******************************************************************

compilation terminated.
*** [.pio\build\esp32dev\lib3a2\hagl\hagl.c.o] Error 1
*** [.pio\build\esp32dev\src\main.cpp.o] Error 1
====================================================================================== [FAILED] Took 2.17 seconds ======================================================================================The terminal process "C:\Users\xXx\.platformio\penv\Scripts\platformio.exe 'run', '--environment', 'esp32dev'" terminated with exit code: 1.

Terminal will be reused by tasks, press any key to close it.

Found a dot that is not rendered at bottom right of screen.

Is that dot is by design or bug?
I used :
ESP-IDF 4.3.1
TTGO T-DISPLAY

I found this dot in your example too (esp_gfx and esp_effect).

Ability to rotate the display at runtime

Hi,

any plan to allow to rotate the display at runtime? Would you be interested in a PR?
Suggestions on how to proceed?

Thanks

Why does text come out so small?

Thank you for this wonderful project. I try to run some of the examples and wonder why text comes out so small, e.g.

Console output:

Allocated back buffer to address 0x7fdad9500000.
w=320, h=240
w=6

This is the code:

hagl_backend_t *display = hagl_init();
printf("w=%d, h=%d\n", display->width, display->height);
grid(display); // code omitted
uint16_t w = hagl_put_text(display, (const wchar_t *)u"Schön bunt hier", 20, display->height / 2.0, 0xffff, font6x9);
printf("w=%d\n", w);
```

Esp8266 support?

Hello. Is esp8266-rtos-sdk supported?

Big stack allocations

The library has "no dynamic allocations" but that's at the expense of large structures allocated on the stack. E.g. here and here. (I'm not even sure how the latter one works under ESP-IDF with its default stack size of ~3K for the main thread.)

Further, the HAGL_CHAR_BUFFER_SIZE calculation might have a bug as you are dividing the DISPLAY_DEPTH by 2, while I believe it should be by 8?

Full list of supported displays/chips

Awesome library, love it!

Could you provide a complete list of existing drivers with the names of the supported controllers?
For example, I have a display based on ST7789 and before I write a driver for HAGL for this chip on ESP32, it would be very convenient to look at the list and check if someone has already written it.

cmake doesn't work

I'm using linux. Running cmake from a fresh checkout fails with:

Unknown CMake command "idf_component_register".

According to google, that's something related to ESP, which is not my platform. I kinda assumed it was not bound to ESP ("hardware agnostic"). Did I miss something ? Or should it be fixed ?

While I'm at it. If i understand well, the MIPI "driver" is only for SPI displays. Is it planned to support parallel (8bit) displays ? Would it be difficult to add ?

Hex to rgb565


uint16_t util_color_to_rgb565(const char *color)
{
  int red, green, blue;
  sscanf(color, "%02x%02x%02x", &red, &green, &blue);
  return ((red & 0xF8) << 8) | ((green & 0xFC) << 3) | (blue >> 3);
}

adding this to make use of taking string hex to convert to rgb565

Add HAL for Raspberry Pi Pico VGABOARD

Hello,

It would be great to have an HAL for Raspberry Pi Pico VGABOARD as documented in https://github.com/raspberrypi/pico-extras/tree/master/src/common/pico_scanvideo/ & al. and implemented by Pimoroni with the VGA Demo Board.

Regards,

Decide font format

Current font format is not good. Should use a readily available font format.

http://elm-chan.org/docs/dosv/fontx_e.html
https://en.wikipedia.org/wiki/Glyph_Bitmap_Distribution_Format
https://en.wikipedia.org/wiki/Portable_Compiled_Format

null hal / qemu hal

Hi,

I'm trying to build an esp32 based project with both the hagl_hal (hagl_esp_mipi) and a qemu_hal which currently does nothing but I would like to expose the screen via network for testing purposes. It works fine when I use the real hal but I have issues using the qemu hal as it conflicts with the other hal at build time even if I don't require it explicitly my project.

The README for this repo states that to build a hal you need to implement hagl_hal_put_pixel which I did - and I was planning to choose the hal at compile time by including the hal header from hagl_esp_mipi vs my basic hal function based on some sdkconfig.

I noticed that hagl.h includes hagl_hal.h and also that hagl CMakeFile requires hagl_hal

I also noticed that at the very minimum hagl_hal.h needs to provide not just the hagl_hal_put_pixel function but also the color_t definition.

Do you have suggestions on how to use one hal vs another in esp32?

DISPLAY_DEPTH < 8

How do I write a driver that works with bitmap_t for a 4-bit color display controller?
As far as I can see, bitmap_t does not correctly support DISPLAY_DEPTH < 8 bits.

Generating new fonts

Hi,

Thanks for your helpful project !

How do you generate new fontx fonts in c code to be used with your library ?

Thanks,
Ronan

Support for getScreen?

Feature Request

In addition to getPixel would it be significant effort to have a getScreen or 'dumpScreenToImage`, write to SD

Use Case

I would like to be able to capture the screen, dump it to SD so I can draw it later

[Minor] README.md contains 2 "Draw a line" sections

cf. https://github.com/tuupola/hagl/#draw-a-line and https://github.com/tuupola/hagl/#draw-a-line-1

Add support for loading images

https://github.com/kikuchan/pngle
http://elm-chan.org/fsw/tjpgd/00index.html

Overflow bug in hagl_scale_blit

If the source bitmap has more than 256 pixels, the scaling produces a wrong result due to a bad cast:

color = ptr[(uint8_t)((py * source->width) + px)];

Should be:

color = ptr[(py * source->width) + px];

Which IDE used ?

hello, please can i know whict i the best IDE recommanded to program a RPI PICO or PICO W
And on wich IDE can i easily use this librairies ?

[Low prio] Offscreen drawing in a bitmap

Given that HAGL is essentially a software rasterizer (with an option to delegate a few things to the HAL below), I'm a bit surprised that bitmap_t is missing all the draw* and fill* methods that you've done for the "main" HAGL surface. The only difference between the bitmap variants and the regular ones is that in the bitmap variants you need a bitmap version of hagl_get_pixel and hagl_put_pixel. Which would be good to have anyway.

Treating bitmap_t as a valid offscreen drawing surface might allow you to fold back into the main HAGL project the "double" and "triple" buffering complexity, which (IMO) would reduce the complexity of the "driver" code.

Input API?

Abstracting the way input is handled within the Backend will mean an easy way to implement different HAGL applications and allow running able them across different backends.

Is this something that you've been considering? Maybe like a keystate() or input() callback or something to set the input state across input devices.

Scaling fonts

Is there a way to scale up existing fonts, i.e. use one of the supplied fonts at double/triple etc., the actual size? If not, would a PR that adds this be reasonable?
I'm thinking versions of hagl_put_text / hagl_put_char that take a scale factor as a parameter.

hagl_put_char / hagl_put_text always drawn on black background

Offending line:
https://github.com/tuupola/hagl/blob/master/src/hagl.c#L364

The easiest fix would be for hagl_put_text / hagl_put_char to take a second color parameter which would represent the "background" color in the rasterized bitmap.

A completely different approach would be for HAGL to be reworked to have a notion of "state", which would include the current foreground color (used by draw* and text functions), current background color (used by fill* and text functions) and current font (used by text functions).

But that might be too big of a change.

Include a 8x8 font by default

It would be great to have an 8x8 font in addition to the 5x7, 5x8, 6x9 already supplied.

Recommend Projects

React

A declarative, efficient, and flexible JavaScript library for building user interfaces.
Vue.js

🖖 Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.
Typescript

TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
TensorFlow

An Open Source Machine Learning Framework for Everyone
Django

The Web framework for perfectionists with deadlines.
Laravel

A PHP framework for web artisans
D3

Bring data to life with SVG, Canvas and HTML. 📊📈🎉

Recommend Topics

javascript

JavaScript (JS) is a lightweight interpreted programming language with first-class functions.
web

Some thing interesting about web. New door for the world.
server

A server is a program made to process requests and deliver data to clients.
Machine learning

Machine learning is a way of modeling and interpreting data that allows a piece of software to respond intelligently.
Visualization

Some thing interesting about visualization, use data art
Game

Some thing interesting about game, make everyone happy.

Recommend Org

Facebook

We are working to build community through open source technology. NB: members must have two-factor auth.
Microsoft

Open source projects and samples from Microsoft.
Google

Google ❤️ Open Source for everyone.
Alibaba

Alibaba Open Source for everyone
D3

Data-Driven Documents codes.
Tencent

China tencent open source team.