ultralytics/assets: the shared file store behind Ultralytics YOLO
Shared Ultralytics logos, media, sample images, pretrained model weights, dataset artifacts, and release assets.
At a glance
- What is it?
- It is not a library and it is not a framework. It is the repository that holds Ultralytics logos, sample images, dataset artifacts and the pretrained weights that YOLO tools pull down on first run, and knowing what lives there saves time when a download or a documentation image breaks.
- Who is it for?
- Adopt nothing here and clone it only if you need a pinned copy of a specific asset, because the repository is a file store rather than a package you install. Teams shipping YOLO models in commercial products should read the licence section before treating the weights as free to embed, and the enterprise licence route exists for exactly that case.
- Can I use it commercially?
- Yes, with strict conditions. AGPL-3.0 is a network copyleft licence: if people use a modified version over a network, for example as a hosted service, you must offer them its source code under the same licence.
- Is it still maintained?
- Yes. The repository last received commits 16 days ago.
- What is it written in?
- GitHub does not report a main language for this repository.
Answers come from the project's GitHub data, last synced on September 29, 2026, and from our analysis. They are not legal advice.
Editorial analysis
What ultralytics/assets actually is, and who ends up needing it
Most people meet this repository without choosing to. They run a YOLO model, the weights are not on disk, and the library fetches them from here. The README describes the repository as storing "shared Ultralytics assets used across documentation, applications, examples, releases, and model downloads", which covers three groups of files that behave very differently. Visual assets are logos, favicons, social icons, Open Graph images, screenshots, diagrams and banners. Model assets are the pretrained weights that Ultralytics tools download automatically when a file is not already available locally. Dataset assets are release artifacts and examples referenced by the documentation and tutorials.
The audience is narrower than the file count suggests. Documentation writers and web developers need the logo and Open Graph directories so their pages render correctly. Anyone writing a tutorial or filing a bug report needs the sample images under im/. People training or exporting models interact with the weights, usually indirectly. If you are building an application on top of YOLO, you rarely open this repository at all; you depend on its availability and on the URLs staying stable. That is the real service it provides: a fixed address for files that other projects link to by URL rather than by package version.
How the asset flow works: raw URLs, automatic downloads, and release artifacts
There is no build step and no package registry involved. The README gives one pattern for referencing any file, a raw GitHub URL of the form https://raw.githubusercontent.com/ultralytics/assets/main/path/to/asset.ext, and notes that the Ultralytics logotype is served from exactly that route under logo/. Documentation, notebooks, websites and examples all point at these URLs, which means the repository is consumed over HTTP rather than through an import.
Model weights take a different path. The README states that Ultralytics YOLO libraries download supported pretrained models from this repository automatically when the requested model is not found locally. So the first call to a model name triggers a network fetch, and subsequent calls read from the local cache. Dataset artifacts are published through repository releases instead, and the README points readers to the datasets documentation while telling them to review the README, licence and usage notes for each dataset before using it in a project.
The layout is organised by consumer rather than by file type. app/ holds app store badges and onboarding visuals, blog/, og/ and partners/ hold blog, Open Graph and partner media, docs/ holds documentation images and audio, documents/ holds legal and policy documents such as the Contributor License Agreement, im/ holds sample images, logo/ holds logos and favicons, mkdocs/ holds assets for documentation builds, social/ holds social icons, and yolo/, yolov3/, yolov5/ and yolov8/ hold family-specific banners and diagrams. That grouping tells you where to look faster than a search would.
Referencing an asset in your own docs or notebook
The quickest real use is pulling an asset into a page, a notebook or a README. The README documents the raw URL pattern, and the logotype is the worked example it gives. Paste the URL into Markdown or HTML as you would any hosted image.
https://raw.githubusercontent.com/ultralytics/assets/main/logo/Ultralytics_Logotype_Original.svgWhat you should see is the Ultralytics logotype rendered at whatever width you set. The README's own header uses this file with width="320".
For model weights, the README shows the library doing the fetching. This is the whole first-use flow, and there is no separate download command documented.
from ultralytics import YOLO
model = YOLO("yolo26n.pt")
results = model("path/to/image.jpg")The first line imports the class, the second requests a model by filename, and the third runs inference on an image path. The README states that when the requested model is not found locally, the library downloads it from this repository automatically, so the first run of that snippet is the run that touches the network. The README directs readers to the Ultralytics model documentation for the available model families, tasks and export options, which is where you check whether the name you typed is a supported one.
Where this repository will not help you
The clearest limitation is that the README does not document rollback, pinning or integrity verification for downloaded weights. It says downloads happen automatically when a model is missing locally, and stops there. It does not describe how to force a re-download of a corrupted file, how to verify a checksum, or how to pin a specific revision of a weight file. If your deployment depends on byte-identical model files across machines, the README does not tell you how to guarantee that, and the repository layout offers no manifest to check against.
Dataset assets carry a second problem: the README explicitly tells readers to review the README, licence and usage notes for each dataset before using it in a project. That sentence is doing real work. Dataset licensing is per-dataset here, and the repository-level AGPL-3.0 licence does not automatically answer what you may do with a given dataset artifact. Anyone who assumes one licence covers everything in the tree is reading it wrong.
Finally, this is the wrong place to look for behaviour. It contains no inference code, no training code and no CLI. If your model produces bad detections, or an export fails, nothing in this repository is the cause or the fix. You want the main Ultralytics library and its issue tracker. Treating this as a software project to evaluate will waste your time; it is a distribution surface.
Hosting assets yourself instead of linking to raw GitHub
The obvious alternative is to stop depending on this repository's URLs and serve the same files from your own storage or CDN. The difference is not about features, it is about failure ownership. Linking to a raw GitHub URL means the asset is available as long as the repository and the path exist; the README documents the URL pattern but says nothing about path stability guarantees, so a reorganised directory can break a page you never touched. Copying the logo, favicon or Open Graph image into your own bucket removes that dependency and gives you control over caching headers and availability, at the cost of manually tracking updates when Ultralytics revises its branding.
For model weights the trade-off is sharper. Letting the library download on first use is convenient and is what the README documents. Vendoring the weight files into your own artifact store gives you reproducible deployments and a single point to audit, but you take on the storage and the job of keeping versions current. The README describes no mirroring tool or sync mechanism, so either direction is manual work. There is no built-in option in the repository to prefer a mirror; the choice lives in your infrastructure, not in this project.
Licence terms and what they mean for commercial use
The README states that Ultralytics offers two licensing options. The first is AGPL-3.0, described as an OSI-approved open-source licence for open collaboration and knowledge sharing, with details in the LICENSE file. The second is an enterprise licence, described as a commercial licence for integrating Ultralytics software and AI models into commercial products without AGPL-3.0 requirements, obtained by contacting Ultralytics Licensing.
That second option is the part worth pausing on. The README frames the enterprise licence as the route for commercial products that do not want to meet AGPL-3.0 requirements, which implies the open-source route carries obligations that some commercial integrations cannot accept. If you are embedding YOLO models in a closed product, the licence question is a decision point before the technical one, and it is not answered by the repository contents. This is a summary of what the README says, not legal advice; read the LICENSE file and, where the stakes justify it, get proper counsel.
One more boundary: the repository-level AGPL-3.0 designation does not settle dataset terms. The README's instruction to review each dataset's own licence and usage notes stands separately, and the documents/ directory holds legal and policy material such as the Contributor License Agreement rather than anything that grants usage rights.
Upgrade cost and how releases are organised
There is nothing to upgrade in the conventional sense, because nothing here is installed as a dependency. What changes is the content behind the URLs, and the release history shows how that is paced. The three listed releases are v8.2.0, covering YOLOv8-World and YOLOv9-C/E models, published on 2024-04-17; v8.3.0, covering new YOLO11 models, published on 2024-09-29; and v8.4.0, covering new YOLO26 models, published on 2026-01-13. Model families arrive with releases rather than continuously.
The practical cost is that new model support is coupled to this repository's release cadence. If a model family you want is not in the release list, the README does not offer another way to obtain it. The last push to the repository was on 2026-09-14, so asset additions and fixes do land between releases, but the weights themselves are tied to the release entries above. For a team planning a model upgrade, the thing to check is which release carries the weights you need, not the repository's overall activity. Nothing here requires a migration step, and the README documents no deprecation policy for older asset paths.
Editorial conclusion
Adopt nothing here and clone it only if you need a pinned copy of a specific asset, because the repository is a file store rather than a package you install. Teams shipping YOLO models in commercial products should read the licence section before treating the weights as free to embed, and the enterprise licence route exists for exactly that case. Verify first that the asset you depend on is still reachable at its raw URL, and check the release notes for the model family you intend to use, since the newest weights are published under v8.4.0 while the older families sit under v8.3.0 and v8.2.0.
Frequently asked questions
What is ultralytics/assets used for?
It stores shared Ultralytics assets used across documentation, applications, examples, releases and model downloads, including logos, screenshots, sample images, dataset artifacts and pretrained model weights. Ultralytics YOLO libraries fetch supported pretrained models from it automatically when a model is not found locally.
How do I reference an asset from ultralytics/assets in my documentation?
The README documents a raw GitHub URL pattern: https://raw.githubusercontent.com/ultralytics/assets/main/path/to/asset.ext. It gives the logotype at logo/Ultralytics_Logotype_Original.svg as the worked example.
Where do the pretrained YOLO weights come from?
The README states that Ultralytics YOLO libraries download supported pretrained models from this repository automatically when the requested model is not found locally. Its example constructs a model with YOLO("yolo26n.pt") and then runs it on an image path.
Can I use ultralytics/assets in a commercial product?
The README describes two licensing options: AGPL-3.0 for open collaboration, and an enterprise licence for integrating Ultralytics software and AI models into commercial products without AGPL-3.0 requirements. The enterprise option is obtained by contacting Ultralytics Licensing.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/ultralytics-assets)