Teachable Machine Community: the browser-trained model libraries and the snippets that consume them

Two directories, and they serve different readers

The repository contains two components and it is worth separating them before anything else.

The libraries section contains the machine learning code used in Teachable Machine itself. Under the hood it uses TensorFlow.js, the JavaScript machine learning library, to train and run the models made in a web browser. This is the code that does the actual work.

The snippets section contains markdown snippets that are displayed inside the export panel in the Teachable Machine tool. Those snippets carry code and instructions for using an exported model from languages such as JavaScript, Java and Python.

The split matters because the two halves have different lifecycles. The libraries are the implementation, and changing them changes how every model behaves. The snippets are documentation that happens to live in the repository so it can be served from the same place, which is why they are markdown rather than testable code.

The top level of the repository is correspondingly thin: a .github directory, .gitignore, CONTRIBUTING.md, LICENSE.txt, README.md, the two directories and an animated image. There is no package manifest at the root and no test suite described, so this is not a library you add to a build in the ordinary way.

Image, audio and pose each got a helper library

Inside the libraries section there are separate helper libraries for image, audio and pose, each with its own API. Their purpose is stated in the README: to make it easier to use the models exported by Teachable Machine in your own projects.

That is a different job from the training code. The training code builds a model in the browser from your samples. The helper libraries are what you use afterwards, when you have a model file and want to classify an image, classify a sound, or read a pose, from your own code.

Three modalities is a useful constraint to understand before choosing. Image, audio and pose cover a specific set of tasks: classification and object detection style work on images, sound classification, and body landmark estimation. Anything outside that, such as text, or generative models, is not what these libraries are for, and the README does not describe support for it.

The model artefact is the contract between the two halves. Teachable Machine exports a trained model, and the helper libraries consume it, which is why the export panel is built around snippets rather than around a schema you might otherwise have to reverse-engineer.

The tool is the entry point, not the repository

Teachable Machine itself is a web-based tool at teachablemachine.withgoogle.com, and the README is clear that this repository is not the tool. It contains the components the tool is built from and the documentation the tool shows you.

The intended workflow runs in the browser. You train a computer to recognize your images, sounds and poses without writing any machine learning code, then use the model in your own projects, sites and apps. The tool does the collecting, the training and the exporting; the repository holds the code underneath and the instructions afterwards.

The stated audience is worth quoting in spirit because it shapes what you find here: educators, artists, students, innovators and makers, and the README says no prerequisite machine learning knowledge is required. That is a person exploring an idea, not a team integrating a model into a product.

Which means the right way to use this repository is as a reference and a starting point. Read the snippet for your language, look at the helper library for your modality, and treat the rest as a teaching example rather than a dependency.

Snippets per language, including Java and Python

The snippets cover JavaScript, Java and Python. That is the interesting part of the export design, because a model trained in TensorFlow.js in a browser still has to be usable from a Java service or a Python notebook, and the export panel is where a user first asks how.

The snippets are markdown rather than source files, so they are read rather than tested. They are documentation shipped alongside the code, which is the arrangement that keeps the export panel and the repository in step, and also the arrangement that means a snippet can drift from the library it describes without anything failing.

For an integrator, the practical sequence is to read the snippet first because it shows the intended minimal integration, then open the matching helper library to see what it actually does. Starting from the snippet avoids guessing at an API, and starting from the library avoids trusting prose that has not been exercised.

Java and Python support is what makes this more than a browser toy. An exported model can be used from a backend service in another supported language.

Community ports show the integration paths, and two of them have moved

The README lists community contributions, and the first entry shows how quickly the ecosystem moves. A Teachable Machine Node library for image models by tr7zw is marked archived and now continued at a different repository under the drinkspiller account. The second is a Teachable Machine Mobile library for image models by mstale007.

That is worth pausing on before you plan around either one. A community library that has been archived and forked means the original author stopped and someone else picked it up, which is the normal lifecycle but also a signal that these integrations depend on individual maintainers rather than on a project plan.

The README also points at a place to share projects: the #teachablemachine hashtag on Twitter and the Experiments with Google submission page. The rest of the contact route is opening an issue in this repository, which is a reasonable thing to do for the libraries and the snippets.

For feedback, this is a small project with a public issue tracker and no dedicated forum, so an issue is the direct channel.

An experiment with an Apache-2.0 licence and four months since the last commit

The repository is Apache-2.0 licensed, with LICENSE.txt at the root.

The disclaimer is the part to read carefully. The README says this is an experiment, not an official Google product, that the maintainers will do their best to support and maintain it, and that your mileage may vary. That is not legal hedging, it is a statement about the support commitment you should plan around.

The repository is not archived and the last push was on 2026-06-19, and there are no GitHub releases to pin against, so there is no version number to depend on. Anyone building on this code should copy what they need rather than depend on the branch, because nothing in the repository promises a release.

The README also asks contributors to respect copyright and trademark rights when sharing derivative work, and points at Google's permissions page for the underlying policy. That is the right caution for a project whose output is models and demos derived from a Google tool: the code licence covers the code, and the trademark question about the Teachable Machine name is separate from it.

Where this is the wrong tool

The clearest wrong-tool case is anything beyond a prototype. The stated audience is people exploring an idea, and the disclaimer says as much. There is no versioning, no published release, and an experiment's support commitment, which is not what a production service should be built on.

The second case is a task outside image, audio and pose. Those three modalities are the scope of the helper libraries, and no other model type is described. If your problem is text, tabular data or generation, this repository is not where the answer is.

The third is a browser-free training requirement. The library design is to train in a web browser with TensorFlow.js, and while the exported models are consumable from Java and Python, the training path documented here is the browser one. A team that must train in a controlled environment, on its own hardware, with its own data handling, needs a training setup this repository does not describe.

Used within those limits, it is a genuinely useful reference: a small, readable, permissively licensed example of training and serving a model across three languages.

Editorial conclusion

Adopt these libraries when you want the exact runtime path Teachable Machine produces, since training in the browser and running with the same TensorFlow.js libraries removes the conversion step that usually breaks a prototype between the tool and the product. Do not adopt the repository itself as a dependency you build on without reading the code, since it is described as an experiment and its audience is people exploring an idea rather than teams shipping a service. Verify first that the model format your exported model uses still matches the helper API in the libraries section, and read the snippets for your target language before writing integration code of your own.

Frequently asked questions

Official sources

1. googlecreativelab/teachablemachine-community on GitHub
2. Issues
3. License: Apache-2.0
4. Project website
5. README