# ATS

> programming language

**Wikidata**: [Q621618](https://www.wikidata.org/wiki/Q621618)  
**Wikipedia**: [English](https://en.wikipedia.org/wiki/ATS_(programming_language))  
**Source**: https://4ort.xyz/entity/ats

## Summary

ATS is a software application influenced by Dependent ML, ML, OCaml, and C++.

## Summary
ATS is a statically-typed, functional programming language created at Boston University in 2006 that combines theorem proving with practical systems programming. It extends Dependent ML with linear types and is designed for writing high-assurance software that can be formally verified.

## Key Facts
- Inception: 2006 at Boston University
- License: GNU General Public License v3.0
- Based on: Dependent ML
- Influenced by: ML, OCaml, Dependent ML
- Typing disciplines: static, dependent, linear
- Programming paradigms: declarative, functional
- Primary use: formal verification and automated theorem proving
- Official website: http://www.ats-lang.org/
- Logo: Available on Wikimedia Commons as "The ATS Logo.svg"
- Wikipedia articles available in: Catalan, German, English, French, Russian

## FAQs
### Q: What makes ATS different from other functional languages?
A: ATS uniquely combines dependent types and linear types, allowing programmers to write proofs about their code that the compiler checks automatically. This enables creation of zero-overhead, formally verified systems software.

### Q: Is ATS still actively maintained?
A: The latest publication date from source archives is January 20, 2015, indicating the project has had releases, though activity levels would need verification from current repositories.

### Q: What kind of software is ATS good for?
A: ATS excels at systems programming where correctness is critical - think device drivers, embedded systems, and security-critical applications where bugs could be catastrophic.

### Q: How does ATS relate to ML?
A: ATS evolved from Dependent ML (DML), an experimental extension of the ML language family. It maintains ML's functional programming style while adding advanced type features for verification.

## Why It Matters
ATS represents a significant achievement in programming language design by bridging the gap between academic research in formal verification and practical systems programming. While most verification-focused languages sacrifice performance for safety, ATS was designed to produce efficient machine code competitive with C, making formal verification practical for performance-critical systems. This addresses a fundamental challenge in software engineering: how to build complex systems that are both fast and provably correct. By integrating theorem proving directly into the programming language, ATS enables developers to write specifications and proofs alongside their code, catching bugs at compile time rather than runtime. This approach could revolutionize how we build critical infrastructure, from operating systems to medical devices, where software failures can have severe consequences.

## Notable For
- First practical language to combine dependent types with linear types for resource management
- Designed to produce C-like performance while maintaining formal verification guarantees
- Extends the ML family with advanced type features for theorem proving
- Enables writing proofs about pointer arithmetic and memory safety in systems code
- Maintains compatibility with C while adding strong static guarantees

## Body
### Origins and Development
ATS emerged from research at Boston University in 2006, building upon the foundation of Dependent ML (DML). DML itself was an experimental extension of ML that added dependent types - types that can depend on values. ATS took this concept further by incorporating linear types, which track resource usage and enable safe manual memory management.

### Language Features
The language implements three distinct typing disciplines:
- Static typing: Standard compile-time type checking
- Dependent typing: Types can depend on runtime values, enabling precise specifications
- Linear typing: Resources must be used exactly once, preventing memory leaks and use-after-free bugs

These features combine to create a language where programs can be proven correct at compile time. The type system is powerful enough to encode complex invariants about data structures and algorithms.

### Practical Applications
ATS targets systems programming domains where both performance and correctness are paramount. The language compiles to efficient C code, allowing it to integrate with existing systems while providing strong safety guarantees. This makes it suitable for:
- Operating system kernels
- Device drivers
- Embedded systems
- Cryptographic implementations
- Any software where formal verification is worth the additional development effort

### Current Status
While the language has demonstrated impressive capabilities in research contexts, with Wikipedia articles in five languages indicating international interest, its adoption has remained primarily in academic and specialized industrial settings. The combination of advanced type theory concepts with practical programming has created a steep learning curve that has limited mainstream adoption.

## Schema Markup
```json
{
  "@context": "https://schema.org",
  "@type": "Thing",
  "name": "ATS",
  "description": "A statically-typed functional programming language for formal verification and systems programming",
  "url": "http://www.ats-lang.org/",
  "sameAs": ["https://www.wikidata.org/wiki/Q2407", "https://en.wikipedia.org/wiki/ATS_(programming_language)"],
  "additionalType": "programming language"
}

## References

1. Category:Dependently typed languages
2. [The ATS PL System - Browse /ats-lang at SourceForge.net](https://sourceforge.net/projects/ats-lang/files/ats-lang/)
3. Freebase Data Dumps. 2013