The Taichi Programming Language

Overview

• Why new programming language
  • Design decisions
• Installation
  • Troubleshooting
    • Windows issues
    • Python issues
    • CUDA issues
    • OpenGL issues
    • Linux issues
    • Other issues
• Hello, world!
  • import taichi as ti
  • Portability
  • Fields
  • Functions and kernels
  • Parallel for-loops
  • Interacting with other Python packages
    • Python-scope data access
    • Sharing data with other packages

Basic Concepts

• Kernels and functions
  • Taichi-scope vs Python-scope
  • Kernels
    • Arguments
    • Return value
    • Advanced arguments
  • Functions
    • Arguments and return values
    • Advanced arguments
• Type system
  • Supported types
  • Type promotion
  • Default precisions
  • Type casts
    • Implicit casts
    • Explicit casts
    • Casting vectors and matrices
    • Bit casting
• Fields and matrices
  • Scalar fields
  • Matrix fields
  • Matrix size
• Interacting with external arrays
  • API reference
    • Interacting with NumPy
    • Interacting with PyTorch
  • External array shapes
  • Using external arrays as Taichi kernel arguments

API References

• Scalar fields
  • Declaration
  • Accessing components
  • Meta data
• Vectors
  • Declaration
    • As global vector fields
    • As a temporary local variable
  • Accessing components
    • As global vector fields
    • As a temporary local variable
    • XYZW vector component accessors
  • Methods
  • Metadata
  • Element-wise operations (WIP)
• Matrices
  • Declaration
    • As global matrix fields
    • As a temporary local variable
  • Accessing components
    • As global matrix fields
    • As a temporary local variable
  • Methods
• Scalar operations
  • Operators
    • Arithmetic operators
    • Logic operators
    • Bitwise operators
  • Functions
    • Trigonometric functions
    • Other arithmetic functions
    • Casting types
    • Builtin-alike functions
    • Random number generator
  • Element-wise arithmetics for vectors and matrices
• Atomic operations
• Structural nodes (SNodes)
  • Node types
  • Working with dynamic SNodes
  • Taichi fields like powers of two
  • Indices

Advanced Programming

• Metaprogramming
  • Template metaprogramming
  • Dimensionality-independent programming using grouped indices
  • Field metadata
  • Matrix & vector metadata
  • Compile-time evaluations
  • When to use for loops with ti.static
• Advanced dense layouts
  • From shape to ti.root.X
  • Row-major versus column-major
  • Array of Structures (AoS), Structure of Arrays (SoA)
  • Flat layouts versus hierarchical layouts
  • Struct-fors on advanced dense data layouts
  • Examples
• Sparse computation (WIP)
• Differentiable programming
  • Introduction
  • Using ti.Tape()
    • Usage example
  • Using kernel.grad()
  • Kernel Simplicity Rule
  • DiffTaichi
• Performance tuning
  • For-loop decorators
    • Thread hierarchy of GPUs
    • API reference
• Objective data-oriented programming
• Syntax sugars
  • Aliases
• Coordinate offsets

Contributing

• Developer installation
  • Installing Dependencies
  • Setting up CUDA (optional)
  • Setting up Taichi for development
  • Troubleshooting Developer Installation
  • Docker
    • Build the Docker Image
    • Use Docker Image on macOS (cpu only)
    • Use Docker Image on Ubuntu (with CUDA support)
• Contribution guidelines
  • How to contribute bug fixes and new features
  • High-level guidelines
  • Effective communication
  • Making good pull requests
  • Reviewing & PR merging
  • Using continuous integration
  • Enforcing code style
  • PR title format and tags
  • C++ and Python standards
  • Tips on the Taichi compiler development
  • Folder structure
  • Testing
    • Command line tools
  • Documentation
  • Efficient code navigation across Python/C++
  • Upgrading CUDA
• Workflow for writing a Python test
  • Adding a new test case
  • Testing against multiple backends
  • Using ti.approx for comparison with tolerance
  • Parametrize test inputs
  • Specifying ti.init configurations
  • Exclude some backends from test
• Developer utilities
  • Logging
  • Benchmarking and regression tests
  • (Linux only) Trigger gdb when programs crash
  • Code coverage
  • Interface system (legacy)
  • Serialization (legacy)
  • Progress notification (legacy)
• Profiler
  • KernelProfiler
  • ScopedProfiler
• C++ style
  • Naming
  • Dos
  • Don’ts
  • Automatic code formatting
• Life of a Taichi kernel
  • Kernel registration
  • Template instantiation and caching
  • Code transformation and optimizations
  • The just-in-time (JIT) compilation engine
  • Kernel launching
• Internal designs (WIP)
  • Intermediate representation
  • Data structure organization
  • List generation (WIP)
  • Statistics
  • Why Python frontend
  • Virtual indices v.s. physical indices
• TaichiCon
  • Past Conferences
  • Format
  • Language
  • Time and frequency
  • Attending TaichiCon
  • Preparing for a talk at TaichiCon
  • Organizing TaichiCon
• Versioning and releases
  • Pre-1.0 versioning
  • Workflow: releasing a new version
  • Release cycle

Miscellaneous

• Frequently asked questions
• GUI system
  • Create a window
  • Paint on a window
  • Event processing
  • GUI Widgets
  • Image I/O
  • Zero-copying frame buffer
• Debugging
  • Run-time print in kernels
  • Compile-time ti.static_print
  • Serial execution
  • Runtime assert in kernel
  • Compile-time ti.static_assert
  • Pretty Taichi-scope traceback
  • Debugging Tips
    • Static type system
    • Advanced Optimization
• Export your results
  • Export images
    • Export images using ti.GUI.show
    • Export images using ti.imwrite
  • Export videos
  • Install ffmpeg
    • Install ffmpeg on Windows
    • Install ffmpeg on Linux
    • Install ffmpeg on OS X
  • Export PLY files
    • Import ply files into Houdini and Blender
• Command line utilities
  • Examples
  • Changelog
  • REPL Shell
  • System information
  • Converting PNGs to video
  • Converting video to GIF
• Global settings
  • Backends
  • Compilation
  • Runtime
  • Logging
  • Develop
  • Specifying ti.init arguments from environment variables
• Export Taichi kernels to C source
  • The workflow of exporting
    • Export YAML
    • Compose YAML into a single C file
  • Calling the exported kernels
    • Specifying scalar arguments
    • Passing external arrays
  • Taichi.js (WIP)
  • Calling Taichi kernels from Julia (WIP)
  • Advanced features
• Extension libraries
  • Taichi GLSL
  • Taichi THREE
• Acknowledgments

Legacy

• Installing the legacy Taichi Library
  • Ubuntu, Arch Linux, and Mac OS X
  • Windows
  • Build with Double Precision (64 bit) Float Point