Coder Social home page Coder Social logo

go-semantic-release / semantic-release Goto Github PK

View Code? Open in Web Editor NEW
395.0 395.0 43.0 3.64 MB

๐Ÿ“ฆ๐Ÿš€ semantic-release written in Go

Home Page: https://go-semantic-release.xyz

License: MIT License

Go 99.17% Shell 0.54% Dockerfile 0.29%
github github-actions gitlab gitlab-ci go semantic-release semantic-version semantic-versioning semver

semantic-release's Introduction

๐Ÿ“ฆ๐Ÿš€ semantic-release

CI pipeline status Go Report Card PkgGoDev

fully automated package/module/image publishing

This project aims to be an alternative to the original semantic-release implementation. Using Go, semantic-release can be installed by downloading a single binary and is, therefore, easier to install and does not require Node.js and npm. Furthermore, semantic-release has a built-in plugin system that allows to extend and customize its functionality.

Features

  • Automated version and release management
  • No external dependencies required
  • Runs on Linux, macOS and Windows
  • Fully extensible via plugins
  • Automated changelog generation
  • Supports GitHub, GitLab and git
  • Support for maintaining multiple major version releases

How does it work?

Instead of writing meaningless commit messages, we can take our time to think about the changes in the codebase and write them down. Following the Conventional Commits specification it is then possible to generate a helpful changelog and to derive the next semantic version number from them.

When semantic-release is setup it will do that after every successful continuous integration build of your default branch and publish the new version for you. This way no human is directly involved in the release process and your releases are guaranteed to be unromantic and unsentimental.

Source: semantic-release/semantic-release#how-does-it-work

You can enforce semantic commit messages using a git hook.

Installation

Option 1: Use the go-semantic-release GitHub Action (go-semantic-release/action)

Option 2: Install manually

curl -SL https://get-release.xyz/semantic-release/linux/amd64 -o ./semantic-release && chmod +x ./semantic-release

Option 3: Install via npm

npm install -g go-semantic-release

Examples

Releasing a Go application with GitHub Actions

Full example can be found at go-semantic-release/example-go-application.

Example .github/workflows/ci.yml config:

name: CI
on:
  push:
    branches:
      - '**'
  pull_request:
    branches:
      - '**'
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-go@v3
        with:
          go-version: 1.19
      - uses: golangci/golangci-lint-action@v3
  test:
    runs-on: ubuntu-latest
    needs: lint
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-go@v3
        with:
          go-version: 1.19
      - run: go test -v ./...
  release:
    runs-on: ubuntu-latest
    needs: test
    permissions:
      contents: write
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-go@v3
        with:
          go-version: 1.19
      - uses: go-semantic-release/action@v1
        with:
          hooks: goreleaser
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

Example GitLab CI Config

GitLab token

It is necessary to create a new Gitlab personal access token with the api scope here. Ensure the CI variable is protected and masked as the GITLAB_TOKEN has a lot of rights. There is an open issue for project specific tokens You can set the GitLab token via the GITLAB_TOKEN environment variable or the -token flag.

.gitlab-ci.yml

stages:
  # other stages
  - release

release:
  image:
    name: registry.gitlab.com/go-semantic-release/semantic-release:latest
    entrypoint: [""]
  stage: release
  # when: manual # Add this if you want to manually create releases
  only:
    - master
  script:
    - semantic-release # Add --allow-no-changes if you want to create a release for each push

Job Token

If you do not provide a PAT the job token will be used. This restricted token can create releases but not read commits. The git strategy must be set to clone so that we can read the commits from the repository. See example below

.gitlab-ci.yml

variables:
  GIT_STRATEGY: clone

stages:
  # other stages
  - release

release:
  image:
    name: registry.gitlab.com/go-semantic-release/semantic-release:latest
    entrypoint: [""]
  stage: release
  # when: manual # Add this if you want to manually create releases
  only:
    - master
  script:
    - semantic-release
    # - semantic-release --allow-no-changes # create a release for each push
    # - semantic-release --provider gitlab --provider-opt log_order=ctime # traverse commits by committer time (commits in merge requests will affect the calculated version) 

Releasing a Go application with GitLab CI

The full example can be found at https://gitlab.com/go-semantic-release/example-go-application.

Example .gitlab-ci.yml config:

image: golang:1.19

stages:
  - test
  - release

test:
  stage: test
  except:
    - tags
  script:
    - go test -v ./...
    - go build ./
    - ./example-go-application

release:
  stage: release
  only:
    - main
  script:
    - curl -SL https://get-release.xyz/semantic-release/linux/amd64 -o ./semantic-release && chmod +x ./semantic-release
    - ./semantic-release --hooks goreleaser

Plugin System

Since v2, semantic-release is equipped with a plugin system. The plugins are standalone binaries that use hashicorp/go-plugin as a plugin library. semantic-release automatically downloads the necessary plugins if they don't exist locally. The plugins are stored in the .semrel directory of the current working directory in the following format: .semrel/<os>_<arch>/<plugin name>/<version>/. The go-semantic-release plugins registry (https://registry.go-semantic-release.xyz/) is used to resolve plugins and to download the correct binary. With the new plugin-registry service the API also supports batch requests to resolve multiple plugins at once and caching of the plugins.

Running semantic-release in an air-gapped environment

As plugins are only downloaded if they do not exist in the .semrel folder, it is possible to download the plugins and archive the .semrel folder. This way it is possible to run semantic-release in an air-gapped environment.

# specify all required plugins and download them
./semantic-release --download-plugins --show-progress --provider github --ci-condition github --hooks goreleaser
# archive the .semrel folder
tar -czvf ./semrel-plugins.tgz .semrel/

# copy the archive to the air-gapped environment

# extract the archive
tar -xzvf ./semrel-plugins.tgz
# run semantic-release
./semantic-release --provider github --condition github --hooks goreleaser

Plugins

Configuration

Plugins can be configured using CLI flags or the .semrelrc config file. By using a @ sign after the plugin name, the required version of the plugin can be specified. Otherwise, any locally installed version will be used. If the plugin does not exist locally, the latest version will be downloaded. This is an example of the .semrelrc config file:

{
  "plugins": {
    "commit-analyzer": {
      "name": "default@^1.0.0"
    },
    "ci-condition": {
      "name": "default"
    },
    "changelog-generator": {
      "name": "default",
      "options": {
        "emojis": "true"
      }
    },
    "provider": {
      "name": "gitlab",
      "options": {
        "gitlab_projectid": "123456"
      }
    },
    "files-updater": {
      "names": ["npm"]
    }
  }
}

Beta release support

Beta release support empowers you to release beta, rc, etc. versions with semantic-release (e.g. v2.0.0-beta.1). To enable this feature you need to create a new branch (e.g. beta/v2) and check in a .semrelrc file with the following content:

{
  "maintainedVersion": "2-beta"
}

If you commit to this branch a new incremental pre-release is created everytime you push. (2.0.0-beta.1, 2.0.0-beta.2, ...)

Licence

The MIT License (MIT)

Copyright ยฉ 2024 Christoph Witzko

semantic-release's People

Contributors

andreassko avatar christophwitzko avatar cliedeman avatar dannylongeuay avatar graugans avatar hazcod avatar sisheogorath avatar soohoowoohoo avatar timoknapp avatar vvbogdanov87 avatar

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

semantic-release's Issues

If there is no change, don't exit with an error code

Currently when the tool runs, if there is no version change detected, it exits with error code 1. This causes our CI process to record these builds as failed, but in reality they were just one of the commit codes that don't cause version changes (docs, style, etc).

I'm not sure if there is a use-case for this being considered an error.

End to End tests

I want to add some end to end tests to avoid issues like go-semantic-release/provider-gitlab#1

My plan is to create a sample repo (Probably a bash script that generates a lot of commits and with branches for each test scenario). Place this repo into github and mirror it to gitlab.

Then we use dry-run tests to verify the output and run them only on master to avoid concurrency issues.

Using BREAKING CHANGE

Hi - just wanted some guidance on using BREAKING CHANGE as specified in the original project docs: https://github.com/semantic-release/semantic-release/blob/master/README.md

There doesn't seem to be support for this as currently this line will fail to match a commit message like BREAKING CHANGE: merry christmas guys:

func parseCommit(commit *github.RepositoryCommit) *Commit {
	c := new(Commit)
	c.SHA = commit.GetSHA()
	c.Raw = strings.Split(commit.Commit.GetMessage(), "\n")
	found := commitPattern.FindAllStringSubmatch(c.Raw[0], -1)
	if len(found) < 1 {
		return c
	}
	c.Type = strings.ToLower(found[0][1])
	c.Scope = found[0][2]
	c.Message = found[0][3]
	c.Change = Change{
		Major: breakingPattern.MatchString(commit.Commit.GetMessage()),
		Minor: c.Type == "feat",
		Patch: c.Type == "fix",
	}
	return c
}

In the code above commitPattern is relying on word characters (\w) to match before the : and so it will not match against BREAKING CHANGE as is not a word character, as such the found array will be empty and the parseCommit function will exit early and not assign a Change to the commit.

I was mainly wondering if this was intentional or not and if you would accept a PR from our fork to resolve this if it is indeed a bug?

Plugins discovery behind proxy

Hi

I'm wondering if there is a way to configure the execution to disable the plugin discoverability feature. Basically the environment where I'm running can't issue any outside calls to fetch packages, and I'm wondering as an alternative to be able to have a docker image with all plugins already packaged to be able to run it

maintained version is not bumped as expected

I'm using the --maintained-version flag with initial value of 2-rc
/usr/local/bin/semantic-release --provider-opt "slug=<repo-name>" --no-ci -f --allow-no-changes --prerelease --maintained-version "2-rc"

[go-semantic-release]: version: 2.6.0
[go-semantic-release]: ci-condition plugin: [email protected]
[go-semantic-release]: provider plugin: [email protected]
[go-semantic-release]: getting default branch...
[go-semantic-release]: found default branch: master
[go-semantic-release]: repo is private
[go-semantic-release]: found current branch: cd290683f0a83df03051f060ffc9bac993be9159
[go-semantic-release]: found maintained version: 2-rc
[go-semantic-release]: found current sha: cd290683f0a83df03051f060ffc9bac993be9159
[go-semantic-release]: getting latest release...
[go-semantic-release]: found version: 2.0.0-rc
[go-semantic-release]: getting commits...
[go-semantic-release]: commit-analyzer plugin: [email protected]
[go-semantic-release]: calculating new version...
[go-semantic-release]: new version: 2.0.0-rc.1
[go-semantic-release]: generating changelog...
[go-semantic-release]: changelog-generator plugin: [email protected]
[go-semantic-release]: creating release...
[go-semantic-release]: done.

Expected behavior:
The newly created version is 2.1.0-rc.

Actual behavior:
The newly created version is 2.0.0-rc.1.

I tried flipping the order and use rc-2, but that is an illegal format according to the command:

 [go-semantic-release]: improper constraint: rc-2

Thanks!

Proposal: Alternative way to package semantic-release

This is a spike to test an alternative way to package semantic-release.

I have an example repo here with
https://github.com/cliedeman/go-semantic-release-example/blob/master/main.go
and a sample pr to do the bare minimum amount of work to test the concept - #87

The idea is that we provide an alternative way to create a semantic object and manually populate the plugins.

Pros:

  • Only uses go.mod, can integrate easily with tools like renovate to stay up to date
  • Testing is easier. Can run like a standard go project, this should make e2e tests a lot easier too
  • We could test against a mock provider that returns a canned set of commits and tags
  • Easier to build a customized docker image fit for purposed
  • Can easily integrate a custom plugin/hooks without pubishing a plugin

Cons

  • Extra entrypoints in semantic-release core
  • Initializing the plugins is somewhat awkward because they accept map[string]string

get-release.xyz appears to be down

I have noticed get-release.xyz seems to be having some issues today. Earlier it appeared the certificate may have expired (but then the problem was resolved) and now when I curl I get the following:

curl: (35) OpenSSL SSL_connect: SSL_ERROR_SYSCALL in connection to get-release.xyz:443 

Not 100% sure what the issue is here but figured it was worth at least noting with an issue.

Prepend new content to CHANGELOG.md

Hi,
I'm not sure whether it's an error in my configurations/environment/something, but I noticed that in our use the CHANGELOG.md gets completely rewritten every time a release has been made, thus losing the history of the change log.
I mean, only the latest changes in the change log are persistent.
I mean, if I currently had only contents of version 0.2.0 in my change log, now I run the semantic-release again and the file contains ONLY the contents of version 0.3.0 and nothing from the versions before this.

If this is expected behaviour, I think adding at least a flag/configuration option for it would be better, so that users could decide whether they wanted to keep the history or have only the latest changes in the file.

Feat: Force bump patch version, if no changes are found

Hi @christophwitzko ,

while being pretty happy with the current feature-set of your semantic-release implementation, I notice a missing feature which would be pretty helpful for our release process. Is it already possible that you can "force bump" the patch version of a release if there are no changes found in the commit history? I totally know that it then might not comply with the standards of semantic versioning, but it can sometime happen that you need to push a hotfix and therefore did not actually use a conventional commit compliant commit message. It happened already twice to us, which then forced me to perform some manual tasks again, which of course is not great either.

I furthermore found a similar feature in a more legacy-ish implementation than yours. In here the config flag is called:

--bump-patch, -p Bump patch number if no changes are found in log

Would be great if you agree to put something similar into your implementation. I would be also fine creating a PR for this.

Cheers
Timo

Semantic Release does not fetch most recent releases from GitHub

Hi @christophwitzko ,

I just stumpled upon a pretty weird behaviour regarding the way semantic-release fetches the releases of the relevant repository. While using semantic-release with GitLab in production for quite a while now, I just noticed that in GitHub it wont fetch the latest tags (Releases) and therefore wont generate the new semantic-version correctly.

Here is a sample repo of mine:

List of tags

image

When running the action afterwards it does not fetch the latest tag being 1.3.0 and therefore still shows the version 1.2.4. (You can ignore my custom made build numbers +XXX) Also don't bother the execution in dry - mode, its only used for extracting the semantic-version and combine it with the build number.

Semantic Release in GitHub Action

image

I also ran semantic-release locally to be sure that its the same behaviour and unfortunately it is consistent:

image

Do you know where this could be coming from?

Thanks in advance!
Timo

Tag as a release candidate?

Hi,
Is their a way to get semrel to tag the release as a release candidate e.g. 1.3.4-rc1 ?
And to get this via commit message (e.g. if I specify fix(xxx):.... RC) it will tag as such ?
Thanks

Deploy to demo, production?

Hi,

So I have a workflow where if I push to master (production) or demo (tda), a new release is created and docker images are pushed using this tag. I extract the version out of .version.

However whenever I want to deploy to production and this is already deployed on demo, the release will already exist and semantic-release will exit without .version file.

Your thoughts on how to handle this?

How to configure the git provider

Hi team,

I'm trying to configure go-semantic-release to use with a generic git repository and keep getting this error:

[go-semantic-release]: authentication required

I've tried setting up GIT_CREDENTIALS similar to the npm semantic release project, setting auth_username, auth_password and auth=basic based on the provider-git, but no luck. The last command I was executing is the following:

semantic-release --alow-initial-development-versions --changelog CHANGELOG.md \
    --changelog-generator-opt emojis=true --provider git --provider-opt auth=basic auth_username=<username> \
    auth_password=<password>

semantic-release V2 has incompatible structure for import through go.mod

the current repo can be used in golang projects with import through go.mod (see https://github.com/golang/go/wiki/Modules#how-can-i-track-tool-dependencies-for-a-module)

but if we import the V2 version we receive the next error from go:

go: errors parsing go.mod:
/home/sergii/IdeaProjects/some_project/go.mod:7: require github.com/go-semantic-release/semantic-release: version "v2.6.0" invalid: module contains a go.mod file, so major version must be compatible: should be v0 or v1, not v2

It can be fixed following
https://github.com/golang/go/wiki/Modules#releasing-modules-v2-or-higher

will be great to be able to use this repo in golang projects without installing binaries

Please support branch-specific releases

We follow the gitflow process, and I'd like to be able to publish versions with each commit, in a branch-specific way.

For example:

The current version of my project is 1.0.0 and I'm working on a branch, feature/foo. I'd like to publish the project as 1.0.1-foo.1, 1.0.1-foo.2, 1.0.1-foo.3.

When I merge to my develop branch, I'd like to publish 1.0.1-beta.1. Subsequent merges would be 1.0.1-beta.2, etc.

Finally, when I merge to the master branch, I'd like to publish 1.0.1 (or 1.1.0, or 2.0.0 of course, depending on the commit message semantics)

Is this something this project could support?

Can't run semantic release

For some reason most likely my fault here I cant get go-semantic-release to run when building my docker image on circle ci or on my machine

Here is how I install the bin in my machine

https://github.com/LittleKidogo/phoenix-deploy/blob/55d792acafac13f9c2d525c5a1258d4c672db7fe/Dockerfile#L13

Here is how I attempt to run it

#!/bin/bash -eo pipefail
semantic-release -vf -slug littlekidogo/some_app -noci || true
/bin/bash: /usr/local/bin/semantic-release: No such file or directory

However as you can see it always complains that it cant find the binary, would anyone mind helping me out with this?

Add --config path for .semrelrc location

For my golang project structure layout, my ci/cd related scripts/configs are located in /build

I do this with other tools such as

golangci-lint run --config build/golangci-lint/.golangci.yml
goreleaser --config build/goreleaser/.goreleaser.yaml

I would like a flag option to set the config file location via --config.

How to release patches for older version

I have a branch setup like release-1 and release-2 which releases version like 1.x.x and for release-2 -- 2.x.x. How i can release a patch from release release-1 branch, default branch is switched to release-2

Renew let's encrypt SSL certificate

It looks like the get-release.xyz SSL certificate expired today. It can easily be renewed with certbot-auto renew (there is a --dry-run option if you want to try it out).

ssl error

Feature request: create chore commit for semantic release

When running semantic-release to update the version file with -vf, the current commit is used to create the semantic release tag, then the version file is updated, but without being pushed up to GitHub.

It would be nice to follow the behavior of the js version of semantic release, which creates a commit, then tags that commit. This would allow any CI processes to be version-aware based on the .version file. See https://github.com/semantic-release/semantic-release#release-steps

This can also work if the --dry flag updates the version file instead of erroring out as mentioned in #29 and #70

After release it doesn't update local repo

After release it doesn't update local repo, so when you check for latest tag it shows the older version.

I am using followin command to get latest tag -

git describe --abbrev=0 --tags

When repo is pulled again then it shows the lates version.

probably should not write .npmrc

Hi, the .npmrc being written when we enable -update package.json is causing problems for us. I've had to comment it out in our branch. We publish most of our packages to a 3rd party repository which uses different authentication settings. We don't set $NPM_TOKEN, and our npmrc files look different than the one hard coded in this project.

It seems to me deployment strategy is out of scope of this project, since many people will have different needs, so I don't think the project should be writing .npmrc. For us, we have a shell script setupNpm.sh that our CI tool runs that configures our permissions as necessary.

A new calculated version in dry mode returns error

Hi,
The command exits with exit code 65 when using dry run mode to test a new calculated release, see here.

I'm using this mode in the CI to verify a new release is calculated (but not released yet) as part of a PR.

I was wondering if I'm using the tool wrong or if we can change it to exit with exit code 0.

The command I am executing is: /usr/local/bin/semantic-release --provider-opt "slug=<repo-name>" --no-ci -f --allow-no-changes --dry

Using Jenkins for CI.

Thanks!

The initial run of semantic-release automatically increments the MAJOR version

I'm experiencing something unexpected on the initial run of semantic-release. The MAJOR version is incremented, but a "BREAKING CHANGES" commit hasn't been made.

There have been a number of feat commit messages pushed, with the expectation of the MINOR version incrementing.

For example, if the tagged version is currently v0.0.0 and a commit is pushed feat(app): new feature I expect the updated version to be v0.1.0, but I'm seeing v1.0.0

Idea: Maintenance Releases

This is quite a tricky feature so nothing might ever come of this issue.

https://semantic-release.gitbook.io/semantic-release/usage/workflow-configuration

Hypothetical Scenario:

  • create release 1.0.0 from master branch
  • branch release-1.0.x is created. (whenever a new minor is created a matching release branch is created)
  • dev continues on master branch and 1.0.0 enters QA
  • bugfix/patch needs to be created for 1.0.0
  • fixes merged onto branch release-1.0.x
  • release triggered on branch release-1.0.x
  • version 1.0.1 created

Requirements

  • only fixes (patch level) can be merged into a release branch. Anything else will result in an error
  • when a release branch get a patch this will force a minor on the next master release
  • If there is a patch release done on master trying to do a patch on the release branch will eror
  • This is opt in behaviour

--allow-no-changes skips .version file

Hi, using --allow-no-changes does not create a .version file.
Ideally for the results to be consistent in a CI/CD scenario, the .version file should contain the current version.

./semantic-release --allow-no-changes -vf --token ${{ secrets.GITHUB_TOKEN }} --changelog .changelog
if [ ! -f .version ]; then echo ".version not found"; exit 1; fi
...
[semantic-release]: detected CI: GitHub Actions
20
[semantic-release]: releasing on: GitHub
21
[semantic-release]: getting default branch...
22
[semantic-release]: found default branch: master
23
[semantic-release]: repo is private
24
[semantic-release]: found current branch: master
25
[semantic-release]: found current sha: d9b957e0be338025a1452fd5f18c5506666ece22
26
[semantic-release]: running CI condition...
27
[semantic-release]: getting latest release...
28
[semantic-release]: found version: 1.0.0
29
[semantic-release]: getting commits...
30
[semantic-release]: calculating new version...
31
[semantic-release]: no change
32
.version not found

Migration from Travis org to com

Travis is migrating open source repo to travis.com. When I tried to deploy a new public repository on travis.com I get this error:

[semantic-release]: running CI condition...
[semantic-release]: GET https://api.travis-ci.org/builds/96825862: 404 

Is there any way to tell semantic release to use travis.com ?

Proposal: Plugin Interface

There are 2 options I see here.

Option 1:
Create a public entrypoint to execute semantic-release and allow users to pass in a list of plugins

Option 2:
Use the go plugin module and create a plugin interface

Example Plugin hooks and use cases:

PostReleaseCreated:

  • Post message to slack
  • create Release in jira

ProcessChangelog:

  • swap jira tickets with links. E.g. AAA-1 -> AAA-1

GITHUB_TOKEN environemnt variable not detected

Hi, I'm trying to run SR but it won't detect my github token in the environment variable.

tal@FlufenSystem:~$ echo $GITHUB_TOKEN 
mytokendfpo4iwretglksdjfoisduisgd
tal@FlufenSystem:~$ semantic-release 
[semantic-release]: github token missing
tal@FlufenSystem:~$ 

Running Ubuntu 16, installed SR with

- curl -SL https://get-release.xyz/semantic-release/linux/amd64 -o ~/semantic-release && chmod +x ~/semantic-release

Thanks

How do file updaters work?

Hi there,

I've been using the JS implementation and am currently looking into your Go implementation.
I want need to move some files and write the new version number to a VERSION file before the tag is created.

I guess that's what file updaters are for. I saw the example for NPM, but I did not see in the code where the changed files are committed to the repository?

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.