Julia Documentation
Categorys
Constants
Functions
Guides
Keywords
Macros
Methods
Modules
Sections
- "Value types" - Types
- 32-bit (ARMv6, ARMv7) - ARM (Linux)
- @code_warntype - Performance Tips
- @threadcall - Multi-Threading
- A simple TCP example - Networking and Streams
- AArch64 (ARMv8) - ARM (Linux)
- Abstract Arrays - Interfaces
- Abstract Types - Types
- Access arrays in memory order, along columns - Performance Tips
- Accessing Data through a Pointer - Calling C and Fortran Code
- Accessing Global Variables - Calling C and Fortran Code
- Accumulation and clearing - Profiling
- Adding methods - Julia Functions
- Adding probes in libjulia - Instrumenting Julia with DTrace, and bpftrace
- Additional spurious warnings - Using Valgrind with Julia
- Address Sanitizer (ASAN) - Sanitizer support
- Address Sanitizer: easy build - Sanitizer support
- After compiling - Windows
- Allocation - Garbage Collection in Julia
- Allowed Variable Names - Variables
- Alternative installation methods - Installation
- Alternative linear algebra backends - Performance Tips
- Annotated Strings - Strings
- Anonymous Functions - Functions
- Append ! to names of functions that modify their arguments - Style Guide
- Arbitrary Precision Arithmetic - Integers and Floating-Point Numbers
- Architecture Customization - Linux
- Argument Passing Behavior - Functions
- Argument destructuring - Functions
- Argument-type declarations - Functions
- Arithmetic Operators - Mathematical Operations and Elementary Functions
- Array and Vectorized Operators and Functions - Single- and multi-dimensional Arrays
- Array literals - Single- and multi-dimensional Arrays
- Array traits - Single- and multi-dimensional Arrays
- Arrays - Frequently Asked Questions
- Arrays With Missing Values - Missing Values
- Assignment expressions and assignment versus mutation - Variables
- Asynchronous I/O - Networking and Streams
- Asynchronous IO and concurrent synchronous writes - Frequently Asked Questions
- Available probes - Instrumenting Julia with DTrace, and bpftrace
- Avoid changing the type of a variable - Performance Tips
- Avoid confusion about whether something is an instance or a type - Style Guide
- Avoid containers with abstract type parameters - Performance Tips
- Avoid elaborate container types - Style Guide
- Avoid strange type Unions - Style Guide
- Avoid string interpolation for I/O - Performance Tips
- Avoid type piracy - Style Guide
- Avoid untyped global variables - Performance Tips
- Avoid using floats for numeric literals in generic code when possible - Style Guide
- Avoid writing overly-specific types - Style Guide
- Background - Julia SSA-form IR
- Backporting commits - Binary distributions
- Base._start - Initialization of the Julia runtime
- Basic Functions - Single- and multi-dimensional Arrays
- Basic Stream I/O - Networking and Streams
- Basic Task operations - Asynchronous Programming
- Basic usage - Profiling
- Be careful with type equality - Style Guide
- Binary distribution - Windows
- Bitwise Operators - Mathematical Operations and Elementary Functions
- Boolean Operators - Mathematical Operations and Elementary Functions
- Break functions into multiple definitions - Performance Tips
- Broadcasting - Single- and multi-dimensional Arrays
- Broken Locks - Proper maintenance and care of multi-threading locks
- Browser-based workflow - Workflow Tips
- Build dependencies - Building Julia (Detailed)
- Build system changes - Julia v1.11 Release Notes
- Building 32-bit Julia on a 64-bit machine - Building Julia (Detailed)
- Building Julia - Building Julia (Detailed)
- Building Julia from source with a Git checkout of a stdlib - Building Julia (Detailed)
- Building Julia with a different version of LLVM - Working with LLVM
- Building an "assert build" of Julia - Building Julia (Detailed)
- Building test binaries - Binary distributions
- Building the Julia system image - System Image Building
- Builtins - Julia Functions
- Byte Array Literals - Strings
- C ABI - Calling Conventions
- C Wrapper Examples - Calling C and Fortran Code
- C++ - Calling C and Fortran Code
- Calling Convention - Calling C and Fortran Code
- Calling Julia Functions - Embedding Julia
- Case Study: Rational - Constructors
- Categories of IR nodes - Julia SSA-form IR
- Caveats - Multi-Threading
- Caveats - Using Valgrind with Julia
- Channels and RemoteChannels - Multi-processing and Distributed Computing
- Characters - Strings
- Checking for package breakages - Binary distributions
- Checking for performance regressions - Binary distributions
- Closing a Library - Calling C and Fortran Code
- Closure cfunctions - Calling C and Fortran Code
- Closures - Julia Functions
- ClusterManagers - Multi-processing and Distributed Computing
- Cmd Objects - Running External Programs
- Code Availability and Loading Packages - Multi-processing and Distributed Computing
- Code Generation - Metaprogramming
- Command-line option changes - Julia v1.11 Release Notes
- Command-line switches for Julia - Command-line Interface
- Common Operations - Strings
- Communicating with Channels - Asynchronous Programming
- Communication and data-races between threads - Multi-Threading
- Comparison with backtrace - Stack Traces
- Compiler efficiency issues - Julia Functions
- Compiler/Runtime improvements - Julia v1.11 Release Notes
- Compiling Methods - Ahead of Time Compilation
- Completeness of analysis - Static analyzer annotations for GC correctness in C code
- Complex Numbers - Complex and Rational Numbers
- Composite Types - Types
- Compound Expressions - Control Flow
- Comprehensions - Single- and multi-dimensional Arrays
- Computing cluster - Frequently Asked Questions
- Concatenation - Strings
- Conclusion - Code Loading
- Conditional Evaluation - Control Flow
- Configuration - Profiling
- Consider StaticArrays.jl for small fixed-size vector/matrix operations - Performance Tips
- Consider using views for slices - Performance Tips
- Constants - Scope of Variables
- Construction and Initialization - Single- and multi-dimensional Arrays
- Constructors - Julia Functions
- Constructors are just callable objects - Constructors
- Control Flow and Short-Circuiting Operators - Missing Values
- Conversion - Conversion and Promotion
- Converting Types - Embedding Julia
- Copying data is not always bad - Performance Tips
- Core.eval - Initialization of the Julia runtime
- Creating C-Compatible Julia Function Pointers - Calling C and Fortran Code
- Creating generic functions - Julia Functions
- Custom pretty-printing - Types
- Customizing broadcasting - Interfaces
- Data Movement - Multi-processing and Distributed Computing
- DataType fields - Reflection and introspection
- DataType layout - Reflection and introspection
- Dealing with signals - gdb debugging tips
- Debugging LLVM transformations in isolation - Working with LLVM
- Debugging a cross-compiled build under wine - Windows
- Debugging and profiling - Environment Variables
- Debugging compiler.jl - Inference
- Debugging during Julia's build process (bootstrap) - gdb debugging tips
- Debugging precompilation errors - gdb debugging tips
- Declared Types - Types
- Defining Methods - Methods
- Defining methods in local scope - Methods
- Definitions - Code Loading
- Deprecated or removed - Julia v1.11 Release Notes
- Design Patterns with Parametric Methods - Methods
- Destructuring Assignment and Multiple Return Values - Functions
- Diagnosing and fixing hangs due to a package dependency - Fixing precompilation hangs due to open tasks or IO
- Diagonal types - More about types
- Displaying Julia variables - gdb debugging tips
- Do-Block Syntax for Function Arguments - Functions
- Don't expose unsafe operations at the interface level - Style Guide
- Don't overload methods of base container types - Style Guide
- Don't overuse ... - Style Guide
- Don't overuse macros - Style Guide
- Don't overuse try-catch - Style Guide
- Don't parenthesize conditions - Style Guide
- Don't use unnecessary static parameters - Style Guide
- Don't write a trivial anonymous function x->f(x) for a named function f - Style Guide
- Dot Syntax for Vectorizing Functions - Functions
- Downloading the Julia source code - Building Julia (Detailed)
- Eliding bounds checks - Bounds checking
- Emit bounds checks - Bounds checking
- Empty generic functions - Methods
- Enabling support - Instrumenting Julia with DTrace, and bpftrace
- Ensure constructors return an instance of their own type - Style Guide
- Environments - Code Loading
- Equality and Comparison Operators - Missing Values
- Error handling - Stack Traces
- Errors during Julia startup - Reporting and analyzing crashes (segfaults)
- Evaluation Scope of Default Values - Functions
- Exception Handling - Control Flow
- Exception stacks and current_exceptions - Stack Traces
- Exceptions - Embedding Julia
- Execution - JIT Design and Implementation
- Execution latency, package loading and package precompiling time - Performance Tips
- Expansion and lowering - Reflection and introspection
- Experimental features - Module loading
- Expressions and evaluation - Metaprogramming
- External Profiling - Profiling
- External applications - Environment Variables
- External dependencies - Julia v1.11 Release Notes
- Extracting useful information - Stack Traces
- Federation of packages - Code Loading
- Fewer dots: Unfuse certain intermediate broadcasts - Performance Tips
- File locations - Environment Variables
- Fix deprecation warnings - Performance Tips
- Fixing package code to avoid hangs - Fixing precompilation hangs due to open tasks or IO
- Flags that impact package image creation and selection - Package Images
- Floating-Point Numbers - Integers and Floating-Point Numbers
- Fortran Wrapper Example - Calling C and Fortran Code
- Free variables - More about types
- Function calls - Julia Functions
- Function composition and piping - Functions
- Function methods - Reflection and introspection
- Function-like objects - Methods
- Functions - Frequently Asked Questions
- Further Reading - Functions
- GC Invariants - Static analyzer annotations for GC correctness in C code
- GC root placement - Working with LLVM
- Garbage Collection Safety - Calling C and Fortran Code
- Garbage collector mark bits - Memory layout of Julia Objects
- General - Frequently Asked Questions
- General Information for Windows - Windows
- General Overview - Static analyzer annotations for GC correctness in C code
- General considerations - Sanitizer support
- General considerations - Using Valgrind with Julia
- General troubleshooting - Building Julia (Detailed)
- Generalizing existing code - Arrays with custom indices
- Generated functions - Metaprogramming
- Generator Expressions - Single- and multi-dimensional Arrays
- Global Scope - Scope of Variables
- Global variables - Multi-processing and Distributed Computing
- Glossary - Reporting and analyzing crashes (segfaults)
- Handle excess argument diversity in the caller - Style Guide
- Heuristics - Garbage Collection in Julia
- High-Level Embedding - Embedding Julia
- High-Level Embedding on Windows with Visual Studio - Embedding Julia
- High-Level Overview - Ahead of Time Compilation
- High-level overview - Package Images
- How inference works - Inference
- IO Output Contextual Properties - Networking and Streams
- Implementation - Single- and multi-dimensional Arrays
- Important Links - Julia 1.11 Documentation
- Improving LLVM optimizations for Julia - Working with LLVM
- Incomplete Initialization - Constructors
- Indentation - Style Guide
- Index replacement - SubArrays
- Indexed Assignment - Single- and multi-dimensional Arrays
- Indexing - Interfaces
- Indexing - Single- and multi-dimensional Arrays
- Indirect Calls - Calling C and Fortran Code
- Inner Constructor Methods - Constructors
- Inserting breakpoints for inspection from gdb - gdb debugging tips
- Inserting breakpoints upon certain conditions - gdb debugging tips
- Instance Properties - Interfaces
- Integers - Integers and Floating-Point Numbers
- Intel VTune (ITTAPI) Profiler - External Profiler Support
- Interface between JL_STD* and Julia code - printf() and stdio in the Julia runtime
- Intermediate and compiled representations - Reflection and introspection
- Interpolation - Running External Programs
- Interpolation - Strings
- Introduction - Ahead of Time Compilation
- Introduction - Garbage Collection in Julia
- Introduction - JIT Design and Implementation
- Introduction - Julia 1.11 Documentation
- Introduction to the internal machinery - More about types
- Iteration - Interfaces
- Iteration - Single- and multi-dimensional Arrays
- JIT Code Generation - Eval of Julia code
- JL Call Convention - Calling Conventions
- Julia Compared to Other Languages - Julia 1.11 Documentation
- Julia Execution - Eval of Julia code
- Julia Native Calling Convention - Calling Conventions
- Julia Releases - Frequently Asked Questions
- Keyword Arguments - Functions
- Keyword arguments - Julia Functions
- Language changes - Julia v1.11 Release Notes
- Legacy ios.c library - printf() and stdio in the Julia runtime
- Libuv wrappers for stdio - printf() and stdio in the Julia runtime
- Linking - JIT Design and Implementation
- Linking - Package Images
- Linux - Binary distributions
- Linux Build Troubleshooting - Linux
- Literal zero and one - Integers and Floating-Point Numbers
- Loading Code Images - Ahead of Time Compilation
- Local Scope - Scope of Variables
- Local invocations - Multi-processing and Distributed Computing
- Locks - Proper maintenance and care of multi-threading locks
- Logical Operations on Arrays - Missing Values
- Logical operators - Missing Values
- Lowered form - Julia ASTs
- Mac and Linux - Installation
- Macro Expansion - Eval of Julia code
- Macros - Metaprogramming
- Main SSA data structure - Julia SSA-form IR
- Mapping C Functions to Julia - Calling C and Fortran Code
- Mapping C Types to Julia - Calling C and Fortran Code
- Marking and Generational Collection - Garbage Collection in Julia
- Measure performance with @time and pay attention to memory allocation - Performance Tips
- Memory - Frequently Asked Questions
- Memory Management - Embedding Julia
- Memory Sanitizer (MSAN) - Sanitizer support
- Memory allocation analysis - Profiling
- Merging backports into the release branch - Binary distributions
- Method Ambiguities - Methods
- Method Tables - Julia Functions
- Method design and the avoidance of ambiguities - Methods
- Method specializations - Methods
- Module bindings - Reflection and introspection
- Module initialization and precompilation - Modules
- More About Callbacks - Calling C and Fortran Code
- More dots: Fuse vectorized operations - Performance Tips
- More task operations - Asynchronous Programming
- Mozilla's Record and Replay Framework (rr) - gdb debugging tips
- Multi-threading changes - Julia v1.11 Release Notes
- Multicast - Networking and Streams
- Multithreading and linear algebra - Performance Tips
- Mutable Composite Types - Types
- Named Tuples - Functions
- Namespace management - Modules
- Network transport - Environment Variables
- New language features - Julia v1.11 Release Notes
- New library features - Julia v1.11 Release Notes
- New library functions - Julia v1.11 Release Notes
- Non-Standard String Literals - Metaprogramming
- Non-Standard String Literals - Strings
- Non-constant Function Specifications - Calling C and Fortran Code
- Note on Optional and keyword Arguments - Methods
- Notes on BLAS and LAPACK - Binary distributions
- Notes on using bpftrace - Instrumenting Julia with DTrace, and bpftrace
- Noteworthy differences from C/C++ - Noteworthy Differences from other Languages
- Noteworthy differences from Common Lisp - Noteworthy Differences from other Languages
- Noteworthy differences from MATLAB - Noteworthy Differences from other Languages
- Noteworthy differences from Python - Noteworthy Differences from other Languages
- Noteworthy differences from R - Noteworthy Differences from other Languages
- Noteworthy external packages - Multi-processing and Distributed Computing
- Nothingness and missing values - Frequently Asked Questions
- Numeric Comparisons - Mathematical Operations and Elementary Functions
- Numeric Literal Coefficients - Integers and Floating-Point Numbers
- Numerical Conversions - Mathematical Operations and Elementary Functions
- OS X - Binary distributions
- Object allocation - Memory layout of Julia Objects
- Object layout (jl_value_t) - Memory layout of Julia Objects
- Operations on Types - Types
- Operator Precedence and Associativity - Mathematical Operations and Elementary Functions
- Operators Are Functions - Functions
- Operators With Special Names - Functions
- Optimization Passes - Custom LLVM Passes
- Optimization Pipeline - JIT Design and Implementation
- Optimize network I/O during parallel execution - Performance Tips
- Optional Arguments - Functions
- Options for controlling the display of profile results - Profiling
- Other generic segfaults or unreachables reached - Reporting and analyzing crashes (segfaults)
- Outer Constructor Methods - Constructors
- Outer-only constructors - Constructors
- Overview - JIT Design and Implementation
- Overview of Julia to LLVM Interface - Working with LLVM
- Package images optimized for multiple microarchitectures - Package Images
- Packages and Modules - Frequently Asked Questions
- Parallel Map and Loops - Multi-processing and Distributed Computing
- Parallel mode - Command-line Interface
- Parallelization - Environment Variables
- Parametric Constructors - Constructors
- Parametric Methods - Methods
- Parametric Types - Types
- Parametrically-constrained Varargs methods - Methods
- Parsing - Eval of Julia code
- Passing options to LLVM - Working with LLVM
- Performance Annotations - Performance Tips
- Performance critical code should be inside a function - Performance Tips
- Performance of captured variable - Performance Tips
- Pipelines - Running External Programs
- Pkg.jl - Environment Variables
- Platform-Specific Notes - Building Julia (Detailed)
- Pre-allocating outputs - Performance Tips
- Prefer exported methods over direct field access - Style Guide
- Primitive Types - Types
- Probe usage examples - Instrumenting Julia with DTrace, and bpftrace
- Program representation - Metaprogramming
- Promotion - Conversion and Promotion
- Propagating inbounds - Bounds checking
- Propagation of Missing Values - Missing Values
- Property destructuring - Functions
- Public API - Frequently Asked Questions
- Quoting - Running External Programs
- REPL formatting - Environment Variables
- REPL-based workflow - Workflow Tips
- Rational Numbers - Complex and Rational Numbers
- Raw String Literals - Strings
- Redefining Methods - Methods
- Regular Expressions - Strings
- Remote References and AbstractChannels - Multi-processing and Distributed Computing
- Repeated Evaluation: Loops - Control Flow
- Representation of Intermediate Values - High-level Overview of the Native-Code Generation Process
- Representation of Pointers - High-level Overview of the Native-Code Generation Process
- Required Build Tools and External Libraries - Building Julia (Detailed)
- Resolving IP Addresses - Networking and Streams
- Resources - Getting Started
- Revise-based workflows - Workflow Tips
- Rounding - Interfaces
- Running the Julia test suite under Valgrind - Using Valgrind with Julia
- Running the LLVM test suite - Working with LLVM
- Running the analysis - Static analyzer annotations for GC correctness in C code
- Safe use of Finalizers - Multi-Threading
- Scripting - Frequently Asked Questions
- Segfaults during bootstrap (sysimg.jl) - Reporting and analyzing crashes (segfaults)
- Segfaults when running a script - Reporting and analyzing crashes (segfaults)
- Semantic Passes - Custom LLVM Passes
- Separate kernel functions (aka, function barriers) - Performance Tips
- Sessions and the REPL - Frequently Asked Questions
- Shared Arrays - Multi-processing and Distributed Computing
- Shared Global Data Structures - Proper maintenance and care of multi-threading locks
- Short-Circuit Evaluation - Control Flow
- Side effects and mutable function arguments - Multi-Threading
- Signing binaries - Binary distributions
- Singleton types - Types
- Skipping Missing Values - Missing Values
- Source distribution - Windows
- Source distributions of releases - Building Julia (Detailed)
- Specialized Calling Convention Signature Representation - High-level Overview of the Native-Code Generation Process
- Specifying Network Topology (Experimental) - Multi-processing and Distributed Computing
- Standard library changes - Julia v1.11 Release Notes
- Starting Julia with multiple threads - Multi-Threading
- Starting and managing worker processes - Multi-processing and Distributed Computing
- Startup file - Command-line Interface
- Static Analysis Algorithm - Static analyzer annotations for GC correctness in C code
- Strided Arrays - Interfaces
- String Basics - Strings
- Stylistic Conventions - Variables
- SubArray design - SubArrays
- Submodules and relative paths - Modules
- Subtypes - Reflection and introspection
- Subtyping and method sorting - More about types
- Subtyping diagonal variables - More about types
- Supported index types - Single- and multi-dimensional Arrays
- Suppressions - Using Valgrind with Julia
- Surface syntax AST - Julia ASTs
- Sweeping - Garbage Collection in Julia
- System Image - Eval of Julia code
- System and Package Image Building - Environment Variables
- System image optimized for multiple microarchitectures - System Image Building
- Tagging the release - Binary distributions
- Target Architectures - Binary distributions
- Target-Dependent Optimization and Code Generation - JIT Design and Implementation
- Task Migration - Multi-Threading
- Tasks (aka Coroutines) - Control Flow
- Tasks and events - Asynchronous Programming
- Text I/O - Networking and Streams
- The @threads Macro - Multi-Threading
- The Main.main entry point - Command-line Interface
- The analyzer annotations - Static analyzer annotations for GC correctness in C code
- The bounds checking call hierarchy - Bounds checking
- The dangers of abusing multiple dispatch (aka, more on types with values-as-parameters) - Performance Tips
- The inlining algorithm (inline_worthy) - Inference
- The jlcall calling convention - Working with LLVM
- The return Keyword - Functions
- Thread Sanitizer (TSAN) - Sanitizer support
- Thread-safety - Calling C and Fortran Code
- Threadpools - Multi-Threading
- Tooling Improvements - Julia v1.11 Release Notes
- Tools - Performance Tips
- Tracy Profiler - External Profiler Support
- Treat Subnormal Numbers as Zeros - Performance Tips
- Triple-Quoted String Literals - Strings
- Troubleshooting "method not matched": parametric type invariance and MethodErrors - Frequently Asked Questions
- Tuple types - More about types
- Tuples - Functions
- Tweaks - Performance Tips
- Type Aliases - Types
- Type Declarations - Types
- Type Inference - Eval of Julia code
- Type Unions - Types
- Type declarations - Performance Tips
- TypeNames - More about types
- Typed Globals - Scope of Variables
- Types and sets (and Any and Union{}/Bottom) - More about types
- Types of functions - Types
- Types with values-as-parameters - Performance Tips
- Types, type declarations, and constructors - Frequently Asked Questions
- Type{T} type selectors - Types
- Unicode and UTF-8 - Strings
- Union representation - High-level Overview of the Native-Code Generation Process
- UnionAll Types - Types
- UnionAll types - More about types
- Update the version number of a dependency - Building Julia (Detailed)
- Updating an existing source tree - Building Julia (Detailed)
- Updating operators - Mathematical Operations and Elementary Functions
- Uploading binaries - Binary distributions
- Use MutableArithmetics for more control over allocation for mutable arithmetic types - Performance Tips
- Use naming conventions consistent with Julia base/ - Style Guide
- Useful Julia functions for Inspecting those variables - gdb debugging tips
- Useful Julia variables for Inspecting - gdb debugging tips
- Useful references: - Instrumenting Julia with DTrace, and bpftrace
- Using arguments inside scripts - Command-line Interface
- Varargs Functions - Functions
- Variables and Assignments - Frequently Asked Questions
- Variadic function calls - Calling C and Fortran Code
- Vectorized "dot" operators - Mathematical Operations and Elementary Functions
- Version Number Literals - Strings
- Version/Environment info - Reporting and analyzing crashes (segfaults)
- Versioning and Git - Binary distributions
- Viewing a stack trace - Stack Traces
- Windows - Binary distributions
- Windows - Installation
- Windows Build Debugging - Windows
- Working with Arrays - Embedding Julia
- Working with Files - Networking and Streams
- Write "type-stable" functions - Performance Tips
- Write functions with argument ordering similar to Julia Base - Style Guide
- Write functions, not just scripts - Style Guide
- Writing custom array types with non-1 indexing - Arrays with custom indices
- ccall interface - Calling C and Fortran Code
- isbits Union Memory - isbits Union Optimizations
- isbits Union Structs - isbits Union Optimizations
- jl_atexit_hook() - Initialization of the Julia runtime
- julia_init() - Initialization of the Julia runtime
- julia_save() - Initialization of the Julia runtime
- main() - Initialization of the Julia runtime
- printf() during initialization - printf() and stdio in the Julia runtime
- repl_entrypoint() - Initialization of the Julia runtime
Types