Git Product home page Git Product logo

go-multihash's Introduction

go-multihash

GoDoc Travis CI codecov.io

multihash implementation in Go

Table of Contents

Install

go-multihash is a standard Go module which can be installed with:

go get github.com/multiformats/go-multihash

Usage

Example

This example takes a standard hex-encoded data and uses EncodeName to calculate the SHA1 multihash value for the buffer.

The resulting hex-encoded data corresponds to: <hash function code><digest size><hash function output>, which could be re-parsed with Multihash.FromHexString().

package main

import (
	"encoding/hex"
	"fmt"

	"github.com/multiformats/go-multihash"
)

func main() {
	// ignores errors for simplicity.
	// don't do that at home.
	// Decode a SHA1 hash to a binary buffer
	buf, _ := hex.DecodeString("0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33")

	// Create a new multihash with it.
	mHashBuf, _ := multihash.EncodeName(buf, "sha1")
	// Print the multihash as hex string
	fmt.Printf("hex: %s\n", hex.EncodeToString(mHashBuf))

	// Parse the binary multihash to a DecodedMultihash
	mHash, _ := multihash.Decode(mHashBuf)
	// Convert the sha1 value to hex string
	sha1hex := hex.EncodeToString(mHash.Digest)
	// Print all the information in the multihash
	fmt.Printf("obj: %v 0x%x %d %s\n", mHash.Name, mHash.Code, mHash.Length, sha1hex)
}

To run, copy to example/foo.go and:

> cd example/
> go build
> ./example
hex: 11140beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33
obj: sha1 0x11 20 0beec7b5ea3f0fdbc95d0dd47f3c5bc275da8a33

Contribute

Contributions welcome. Please check out the issues.

Check out our contributing document for more information on how we work, and about contributing in general. Please be aware that all interactions related to multiformats are subject to the IPFS Code of Conduct.

Small note: If editing the README, please conform to the standard-readme specification.

License

MIT ยฉ 2014 Juan Batiz-Benet

go-multihash's People

Stargazers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

Watchers

 avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar  avatar

go-multihash's Issues

Possibly erroneous tag pushed: v1.0.2

Woof Woof ๐Ÿถ

@Kubuxu looks like you pushed old tag into this repo.
Remove this tag by running git tag -d v1.0.2 && git push origin :v1.0.2

This probably happened because your local git repositories still have old tags.
You can remove all of them in one go by running:
find libp2p multiformats ipfs -maxdepth 1 -mindepth 1 -type d | while read dir; do; cd $dir; git fetch --prune origin '+refs/tags/*:refs/tags/*'; cd ../..; done in $GOPATH/src/github.com/.

Yours truly, with ๐Ÿฉ, Tag Dog.

approach to constants

We need to talk about how this library approaches constants.

Currently:

  • There are a bunch of exported caps-lock constant names in the root multihash package, mapping to mulithash indicator codes.
    • Mostly these are caps-lock and s/-/_/g of the names in the multiformats table...
    • But there are also some others, which point to other sibling constants, and are commented as "DEPRECATED" (...what's the point?)
    • There are some other consts that are referring to ranges rather than specific indicator codes (e.g. for the blakes)
    • There are many multihash indicator code numbers which have a function for them made available by the library, but don't have constants (again, the blakes)
  • There's a Codes = map[uint64]string.
    • But it's only good for the things this library knows about (which is not 100% in sync with the table)
  • There's a Names = map[string]uint64, which is the dual of Codes.

... so, there are numerous consistency issues with the current status quo, and it's very manual to update.

And we have a recently born go-multicodec repo, which contains a bunch of constants!

  • it's automatically generated from the csv table! Super nice!
  • contains no other functionality but the constants. Trivial dependency weight (outside of adding a line item to the go.mod file).
  • (one tangent: I wonder if we should rename this repo to go-multiformat. There was pretty resounding agreement that the word multicodec may be confusingly used to describe too many things the last time the IPLD team talked about this. But I also don't feel the need to hold up any other discussion this / if we do engage this, let's spawn another issue for that conversation.)

And, these questions are all raised afresh by #136 -- wherein we've gotta use something for constants in various places; and the revisitation of the registration features means it's a very good time to check in on where we expect any of these mappings to string names to be handled.

Okay, that's all the background. What shall we do? Discuss.

Possibly erroneous tag pushed: v1.0.2

Woof Woof ๐Ÿถ

@Kubuxu looks like you pushed old tag into this repo.
Remove this tag by running git tag -d v1.0.2 && git push origin :v1.0.2

This probably happened because your local git repositories still have old tags.
You can remove all of them in one go by running:
find libp2p multiformats ipfs -maxdepth 1 -mindepth 1 -type d | while read dir; do; cd $dir; git fetch --prune origin '+refs/tags/*:refs/tags/*'; cd ../..; done in $GOPATH/src/github.com/.

Yours truly, with ๐Ÿฉ, Tag Dog.

correct url in import

Travis ci failed with

> make test
go get golang.org/x/crypto/sha3
go get github.com/jbenet/go-base58
go test -race -cpu=5 -v ./...
multihash/main.go:9:2: cannot find package "github.com/jbenet/go-multihash" in any of:
    /home/travis/.gimme/versions/go1.3.linux.amd64/src/pkg/github.com/jbenet/go-multihash (from $GOROOT)
    /home/travis/gopath/src/github.com/jbenet/go-multihash (from $GOPATH)
multihash/main.go:10:2: cannot find package "github.com/jbenet/go-multihash/opts" in any of:
    /home/travis/.gimme/versions/go1.3.linux.amd64/src/pkg/github.com/jbenet/go-multihash/opts (from $GOROOT)
    /home/travis/gopath/src/github.com/jbenet/go-multihash/opts (from $GOPATH)
make: *** [go_test] Error 1

github.com/jbenet/go-multihash should be github.com/multiformats/go-multihash

Faster sha256 and blake2b implementations

https://github.com/minio/sha256-simd

Accelerate SHA256 computations in pure Go using AVX512 and AVX2 for Intel and ARM64 for ARM. On AVX512 it provides an up to 8x improvement (over 3 GB/s per core) in comparison to AVX2.

This package is designed as a replacement for crypto/sha256. For Intel CPUs it has two flavors for AVX512 and AVX2 (AVX/SSE are also supported). For ARM CPUs with the Cryptography Extensions, advantage is taken of the SHA2 instructions resulting in a massive performance improvement.

This package uses Golang assembly. The AVX512 version is based on the Intel's "multi-buffer crypto library for IPSec" whereas the other Intel implementations are described in "Fast SHA-256 Implementations on Intel Architecture Processors" by J. Guilford et al.

https://github.com/minio/blake2b-simd

This package was initially based on the pure go BLAKE2b implementation of Dmitry Chestnykh and merged with the (cgo dependent) AVX optimized BLAKE2 implementation (which in turn is based on the official implementation. It does so by using Go's Assembler for amd64 architectures with a golang only fallback for other architectures.

In addition to AVX there is also support for AVX2 as well as SSE. Best performance is obtained with AVX2 which gives roughly a 4X performance increase approaching hashing speeds of 1GB/sec on a single core.

Old tag pushed: v0.0.1-pre

Woof Woof ๐Ÿฉ
@Kubuxu looks like you pushed old tag into this repo.
Remove this tag by running git tag -d v0.0.1-pre && git push origin :v0.0.1-pre
Thanks, with ๐Ÿฉ, Tag Dog.

Possibly erroneous tag pushed: v0.0.1-pre

Woof Woof ๐Ÿถ

@Kubuxu looks like you pushed old tag into this repo.
Remove this tag by running git tag -d v0.0.1-pre && git push origin :v0.0.1-pre

This probably happened because your local git repositories still have old tags.
You can remove all of them in one go by running:
find libp2p multiformats ipfs -maxdepth 1 -mindepth 1 -type d | while read dir; do; cd $dir; git fetch --prune origin '+refs/tags/*:refs/tags/*'; cd ../..; done in $GOPATH/src/github.com/.

Yours truly, with ๐Ÿฉ, Tag Dog.

Failure possible in case of large data's multihash

Currently go-multihash is using the in-memory strings as input and generating hashes of those. This can cause an issue in case of a large file given as input (it can't be read to memory). Need to handle hash generation of large data and input file(names?) too.

Error: multihash too short. must be > 3 bytes

Version information:

go-ipfs version: 0.4.13-
Repo version: 6
System version: amd64/windows
Golang version: go1.9.2

Type: Bug

Description:

>ipfs block get z2yYDV
Error: multihash too short. must be > 3 bytes

z2yYDV -> (01 55 00 00) is valid zero length "identity" hash of zero length raw block.

Version tags gone missing?

For example, the following no longer seems to work:
go get github.com/multiformats/[email protected]

Pretty sure it did when

github.com/multiformats/go-multihash v1.0.10 got added to our projects go.mod file.

Separate interface and implementation

Every dependent function that expects or returns a Multihash, should be working with the interface instead of the type. This will make it easier to use go-multihash as a library where various dependents can use various versions of go-multihash. Right now you'll occasionally run into gx/ipfs/<hash>/go-multihash.Multihash is not gx/ipfs/<other-hash>/go-multihash.Multihash.

The same applies for other multiformats libraries.

Go get multihash fails compilation due to sha3.NewLegacyKeccak512

Following readme
$ go get github.com/multiformats/go-multihash

Results
# github.com/multiformats/go-multihash go/src/github.com/multiformats/go-multihash/sum.go:136:7: undefined: sha3.NewLegacyKeccak512

$ go version go version go1.13.8 linux/amd64

on Ubuntu 20.04 LTS

[enhancement] adding BLAKE3 support

BLAKE3 https://github.com/BLAKE3-team/BLAKE3 is a major improvement (https://medium.com/asecuritysite-when-bob-met-alice/blake3-3716708235ac https://news.ycombinator.com/item?id=22021769 https://news.ycombinator.com/item?id=22003315) on BLAKE2 in regards to speed.

There's a pure Go implementation https://github.com/lukechampine/blake3 though it's not optimized yet. An optimized version will become available in x/crypto at some point.

As an enhancement proposal, it would be nice to have at least preliminary BLAKE3 support in multihash so that downstream like IPFS can start using it.

Use different keccakpg import path

vgo: resolving import "leb.io/hashland/keccakpg"
FindRepo: Get https://leb.io/hashland/keccakpg?go-get=1: dial tcp 104.131.190.18:443: connect: connection 
refused                                                                                                  
FindRepo: Get https://leb.io/hashland?go-get=1: dial tcp 104.131.190.18:443: connect: connection refused
FindRepo: Get https://leb.io?go-get=1: dial tcp 104.131.190.18:443: connect: connection refused
vgo: import "github.com/libp2p/go-libp2p" ->
        import "github.com/libp2p/go-libp2p-circuit" ->
        import "github.com/libp2p/go-libp2p-host" ->
        import "github.com/libp2p/go-libp2p-interface-connmgr" ->
        import "github.com/libp2p/go-libp2p-net" ->
        import "github.com/libp2p/go-libp2p-peer" ->
        import "github.com/multiformats/go-multihash" ->
        import "leb.io/hashland/keccakpg": Get https://leb.io/hashland/keccakpg?go-get=1: dial tcp 104.131
.190.18:443: connect: connection refused                                                                 

Currently leb.io has been down, since May.

You could replace the import path with github.com/tildeleb/hashland/keccakpg safely, I think.

Doesn't match gnutools checksums

I was testing hashpipe and notice that my checksum from gnutools "sha1sum" and "sha256sum" doesn't match.

Seems as multihash adds 1114 at the beginning?

    [d@x][] echo "foobar" | ./multihash -a="sha1"   
    5dsufTcJUcGW6FskA3wHdW2PuP6Hvg
    [d@x][]% echo "foobar" | ./multihash -a="sha1" -e="hex"
    1114988881adc9fc3655077dc2d4d757d480b5ea0e11
    [d@x][]% echo "foobar" | sha1sum                                                          
    988881adc9fc3655077dc2d4d757d480b5ea0e11  -
ยดยดยด

Restore `test/foo.go` or change readme

@cryptix just realized the README shows the user how to use multihash using test/foo.go. The reason i had it as a separate program is so a user could see exactly how to use it (and run it) without having to mess with the test suite.

Maybe resurrect it and rename it test/example.go ?

What's going on with murmur3?

This code looks an awful lot like it's doing a murmur3-32, and returning four bytes:

go-multihash/sum.go

Lines 146 to 154 in 6f1ea18

func sumMURMUR3(data []byte, length int) ([]byte, error) {
number := murmur3.Sum32(data)
bytes := make([]byte, 4)
for i := range bytes {
bytes[i] = byte(number & 0xff)
number >>= 8
}
return bytes, nil
}

And this code looks an awful lot like it's registering the above code as murmur3-128, which I suspect ought to return more than four bytes:

RegisterHashFunc(MURMUR3_128, sumMURMUR3)

Should I be worried?

And if this is a bug, how comfortable are we about fixing it vs potentially breaking things that rely on the current behavior?

Convert hash to hex hash and vice versa

In the multihash CLI it would be nice to be able to easily convert from mutltihash to a more common format.

This could also work to convert a hex SHA256 hash to a multithash, for example, without the file.

So something like: multihash -convert_to raw QmVrM1N7FQpbvyDosagm5VrMf58EQk8B1C3K87r2sJVE33 or multihash -convert_to base58 6f9d376ef1f2c899712c49f40d1be02d22ffdc46b2ea9e837a57802a38086bb9

Also useful as a library, although haven't looked around for that yet.

Missing file test/bin

The file https://github.com/multiformats/go-multihash/blob/master/test/sharness/bin is a link to ../bin which would be test/bin. This files does not exist.
I'm working on a project using dep for depency management but also have to install some gx dependencies.

Installing gx/ipfs/QmZyZDi491cCNTLfAhwcaDii2Kg4pwKRkhqQzURGDvY6ua works but dep fails afterwards because the named file is missing.

Probably some corner case but the file should still be present somehow.

Release new Version

Hi, could you release a new version of go-multihash?
I'm currently using golang/dep to manage my dependencies and it installs the old 0.1.0 version from 2014 that doesn't even compile anymore because it's the latest tag. While I do have a workaround, it would be nice if you could do it to prevent future issues.

Generated go constants for multicodecs

Hi everyone,

I saw multiple multicodec constant definitions in e.g. multiformats/go-multihash/multihash.go#L38 and multiformats/go-cid/cid.go#L52. Furthermore the generation of the blake/skein mappings are not obvious.

This motivated me to play around and try to automate the generation based on the "canonical" multicodecs table. The outcome can be found here:

https://github.com/dennis-tra/go-multicodec

The repo contains the multiformats/multicodec repo as a submodule. Every night a GitHub-Action updates the HEAD of the submodule to the most recent master commit, runs the constants generator, commits possible changes and creates a pull request. It will update the same pull request if subsequent runs find different changes and it won't create a pull request if no changes were detected (GitHub-Action: peter-evans/create-pull-request@v3).

Moving the constants to another repo would obviously be a breaking change for others who depend on this go-multihash repo so I see there are strong forces against a proposal like this.

But anyways, I just wanted to leave this here and ask if this would be something that you could benefit from?

Fixing CI

Due to the move the Travis CI is completely broken.

Doesn't work on Go playground

Error:

# github.com/minio/sha256-simd
../gopath677471992/pkg/mod/github.com/minio/[email protected]/cpuid.go:30:14: undefined: haveArmSha
../gopath677471992/pkg/mod/github.com/minio/[email protected]/cpuid.go:50:18: undefined: cpuid
../gopath677471992/pkg/mod/github.com/minio/[email protected]/cpuid.go:53:17: undefined: cpuid
../gopath677471992/pkg/mod/github.com/minio/[email protected]/cpuid.go:68:17: undefined: cpuid
../gopath677471992/pkg/mod/github.com/minio/[email protected]/cpuid.go:87:11: undefined: xgetbv
../gopath677471992/pkg/mod/github.com/minio/[email protected]/sha256.go:82:3: undefined: blockShaGo
../gopath677471992/pkg/mod/github.com/minio/[email protected]/sha256.go:84:3: undefined: blockAvx2Go
../gopath677471992/pkg/mod/github.com/minio/[email protected]/sha256.go:86:3: undefined: blockAvxGo
../gopath677471992/pkg/mod/github.com/minio/[email protected]/sha256.go:88:3: undefined: blockSsseGo
../gopath677471992/pkg/mod/github.com/minio/[email protected]/sha256.go:90:3: undefined: blockArmGo
../gopath677471992/pkg/mod/github.com/minio/[email protected]/sha256.go:90:3: too many errors

https://play.golang.org/p/-Qu2a_wL9tt

Possibly erroneous tag pushed: v0.0.1-pre

Woof Woof ๐Ÿถ

@Kubuxu looks like you pushed old tag into this repo.
Remove this tag by running git tag -d v0.0.1-pre && git push origin :v0.0.1-pre

This probably happened because your local git repositories still have old tags.
You can remove all of them in one go by running:
find libp2p multiformats ipfs -maxdepth 1 -mindepth 1 -type d | while read dir; do; cd $dir; git fetch --prune origin '+refs/tags/*:refs/tags/*'; cd ../..; done in $GOPATH/src/github.com/.

Yours truly, with ๐Ÿฉ, Tag Dog.

Nicer options

this sucks

> multihash --help
usage: multihash [options] [FILE]
Print or check multihash checksums.
With no FILE, or when FILE is -, read standard input.

Options:
  -a string
        one of: sha1, sha2-256, sha2-512, sha3 (shorthand) (default "sha2-256")
  -algorithm string
        one of: sha1, sha2-256, sha2-512, sha3 (default "sha2-256")
  -c string
        check checksum matches (shorthand)
  -check string
        check checksum matches
  -e string
        one of: raw, hex, base58, base64 (shorthand) (default "base58")
  -encoding string
        one of: raw, hex, base58, base64 (default "base58")
  -l int
        checksums length in bits (truncate). -1 is default (shorthand) (default -1)
  -length int
        checksums length in bits (truncate). -1 is default (default -1)
  -q    quiet output (no newline on checksum, no error text) (shorthand)
  -quiet
        quiet output (no newline on checksum, no error text)

this would be nicer

> multihash --help
usage: multihash [options] [FILE]
Print or check multihash checksums.
With no FILE, or when FILE is -, read standard input.

Options:
  -a, --algorithm string  one of: sha1, sha2-256, sha2-512, sha3 (default: sha2-256)
  -c, --check string      check checksum matches
  -e, --encoding string   one of: raw, hex, base58, base64 (default: base58)
  -l, --length int        checksum length in bits (truncate). -1 is default (default: -1)
  -q, --quiet             quiet output (no newline on checksum, no error text)

unrecognized import path "golang.org/x/crypto/blake2b", also with blake2s and sha3

unrecognized import path "golang.org/x/crypto/blake2b"
unrecognized import path "golang.org/x/crypto/blake2s"
unrecognized import path "golang.org/x/crypto/sha3"

Not sure if this is a network problem. Some people on the internet suggest this is network related. But these are the only three packages that gave this error message while executing go get -u github.com/whyrusleeping/gx

$ curl https://golang.org/x/crypto/blake2b?go-get=1

Nothing to see here; move along.

Workaround:
First download the packages manually from github
https://github.com/golang/crypto/tree/master/blake2b
https://github.com/golang/crypto/tree/master/blake2s
https://github.com/golang/crypto/tree/master/sha3

Then put the downloaded packages under the right GOPATH of golang.org/x/crypto/

Possibly erroneous tag pushed: v1.0.2

Woof Woof ๐Ÿถ

@Kubuxu looks like you pushed old tag into this repo.
Remove this tag by running git tag -d v1.0.2 && git push origin :v1.0.2

This probably happened because your local git repositories still have old tags.
You can remove all of them in one go by running:
find libp2p multiformats ipfs -maxdepth 1 -mindepth 1 -type d | while read dir; do; cd $dir; git fetch --prune origin '+refs/tags/*:refs/tags/*'; cd ../..; done in $GOPATH/src/github.com/.

Yours truly, with ๐Ÿฉ, Tag Dog.

Main readme has an incorrect command

In your main readme, it says I should run a command:

gx-go --rewrite

when I did that I get this error:

@./test:jrush>$ gx-go --rewrite
Incorrect Usage. flag provided but not defined: -rewrite

NAME:
   gx-go - gx extensions for golang

USAGE:
   gx-go [global options] command [command options] [arguments...]

VERSION:
   1.9.0

AUTHOR:
   whyrusleeping

COMMANDS:
     dep-map      prints out a json dep map for usage by 'import --map'
     hook         go specific hooks to be called by the gx tool
     import       import a go package and all its depencies into gx
     path         prints the import path of the current package within GOPATH
     rewrite, rw  temporary hack to evade causality
     uw
     update       update a packages imports to a new path
     dvcs-deps    display all dvcs deps
     link         Symlink packages to their dvcsimport repos, for local development.
     lock-gen     Generate a lock file
     devcopy      Create a development copy of the given package
     get          gx-ified `go get`
     help, h      Shows a list of commands or help for one command

GLOBAL OPTIONS:
   --verbose      turn on verbose output
   --help, -h     show help
   --version, -v  print the version
ERROR: Error: flag provided but not defined: -rewrite

test instructions in readme fail

I just followed the test instructions in the readme:

cd test/
go build

And this results in a build error:

eric@finkomatic:~/go/src/github.com/multiformats/go-multihash/test$ go build
can't load package: package github.com/multiformats/go-multihash/test: no buildable Go source files in /home/eric/go/src/github.com/multiformats/go-multihash/test

Split core types into a core subpackage

Currently, the core Multihash type and the Sum function are defined in the same package. This means anyone who wants to import the type also needs to import the sum function, pulling in all the hashing libraries at the same time.

Instead, we should:

  • Split the core types/functions into a core sub package.
  • Add type aliases in the root package to the types moved to the core package.
  • Keep Sum in the root package.

That way, packages that depend on these types can directly import the core package, reducing binary size.

Replaces #78.

Make Multihash a string instead of a []byte?

Currently Multihash is defined as:

type Multihash []byte

A multihash may be binary, but it is small and (I hope) immutable. In my view a string is a better fit since it will ensure that it will not change. It will also take less memory to point too (two pointers, instead of three).

This relates to ipfs/go-cid#3.

Some algorithms don't implement Sum

These algorighms are found in multiformats.Names, but are never registered in sum.go. As a result, attempting to use multiformats.Sum with these algorighms raises ErrSumNotSupported.

I have no need for these, myself, but it seems inconsistent for Sum to work on some algorithms and not others. Is there any reason these are not registered?

keccak-224
x11
keccak-384

Consider removing Sum or moving it to a subpackage

multihash is an encoding for hash values. go-multihash depends on implementations of all the hash functions because it provides the Sum function.

IMHO hashing and encoding the hash value as a "multihash" are two separate things and shouldn't be in the same Go package. Removing/splitting out Sum would make the package much more light-weight because it would reduce non-stdlib dependencies to just github.com/jbenet/base58.

Possibly erroneous tag pushed: v1.0.2

Woof Woof ๐Ÿถ

@Kubuxu looks like you pushed old tag into this repo.
Remove this tag by running git tag -d v1.0.2 && git push origin :v1.0.2

This probably happened because your local git repositories still have old tags.
You can remove all of them in one go by running:
find libp2p multiformats ipfs -maxdepth 1 -mindepth 1 -type d | while read dir; do; cd $dir; git fetch --prune origin '+refs/tags/*:refs/tags/*'; cd ../..; done in $GOPATH/src/github.com/.

Yours truly, with ๐Ÿฉ, Tag Dog.

Recommend Projects

  • React photo React

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

  • Vue.js photo Vue.js

    ๐Ÿ–– Vue.js is a progressive, incrementally-adoptable JavaScript framework for building UI on the web.

  • Typescript photo Typescript

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

  • TensorFlow photo TensorFlow

    An Open Source Machine Learning Framework for Everyone

  • Django photo Django

    The Web framework for perfectionists with deadlines.

  • D3 photo 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.

  • Game

    Some thing interesting about game, make everyone happy.

Recommend Org

  • Facebook photo Facebook

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

  • Microsoft photo Microsoft

    Open source projects and samples from Microsoft.

  • Google photo Google

    Google โค๏ธ Open Source for everyone.

  • D3 photo D3

    Data-Driven Documents codes.