Skip to content

Vala Documentation

Appearance

Sidebar Navigation

Home

About

Installation Guide

Tutorials

Programming Language

Main Tutorial

1. First Program

2. Basics

2.1. Source Files and Compilation

2.2. Syntax Overview

2.3. Comments

2.4. Data Types

2.5. Operators

2.6. Control Structures

2.7. Language Elements

2.8. Code Attributes

3. Object Oriented Programming

3.1. Basics

3.2. Construction

3.3. Destruction

3.4. Signals

3.5. Properties

3.6. Inheritance

3.7. Abstract Classes

3.8. Interfaces

3.9. Polymorphism

3.10. Method Hiding

3.11. Run-Time Type Information

3.12. Dynamic Type Casting

3.13. Generics

3.14. GObject-Style Construction

4. Advanced Features

4.1. Assertions and Contract Programming

4.2. Error Handling

4.3. Parameter Directions

4.4. Collections

4.5. Methods with Syntax Support

4.6. Multi-Threading

4.7. The Main Loop

4.8. Asynchronous Methods

4.9. Weak References

4.10. Ownership

4.11. Variable-Length Argument Lists

4.12. Pointers

4.13. Non-Object Classes

4.14. D-Bus Integration

4.15. Profiles

5. Experimental Features

5.1. Chained Relational Expressions

5.2. Regular Expression Literals

5.3. Strict Non-Null Mode

6. Libraries

6.1. Using Libraries

6.2. Creating a Library

6.3. Binding Libraries with VAPI Files

6.4. ABI and API Design Choices

6.5. Binding to Vala Libraries from Other Languages

6.6. Using Autotools

7. Tools

7.1. valac

7.2. valadoc

7.3. vapigen

7.4. vala-gen-introspect

8. Techniques

8.1. Debugging

8.2. Using GLib

GUI Programming

Tooling

Build Systems

Code Editors and IDEs

Language Server Protocol Support

Other Tools

Syntax Support

Contributor Guide

Compiler Guide

1. Project Information

2. Environment Setup

3. The Vala Compiler

3.1. Vala in a Nutshell

3.2. Parser

3.3. Semantic Analyzer

3.4. Symbol Resolution

3.5. Flow Analyzer

3.6. C Code Generation

3.7. C Code Compilation and Linking

4. Vala Bindings - VAPI

5. libgee Internal

6. Other Tools

7. Testing

8. Documentation

9. Build System

Developer Guides

Bindings

Generating a VAPI with GObject Introspection

Why Distribute Bindings Upstream

Writing a VAPI Manually

1. Prerequisites

2. Getting Started

2.1. The VAPI File

2.2. Attribution and License

2.3. The CCode Attribute

2.4. Create a Root Namespace

2.5. Include the C Header Files

2.6. Symbol Name Translations

2.7. Code Formatting Conventions

2.8. Documentation and Valadoc.org

2.9. The Version Attribute

3. Using Vala's Automatic Memory Management

3.1. Pointers in C (or what all these *'s mean)

3.2. Constants, the Stack and the Heap in C

3.3. The Concept of "Ownership" in Vala

3.4. Binding to C Heap Handlers

4. Recognizing Vala Semantics in C Code

4.1. Constants

4.2. Enums and Flags

4.3. Simple Type Structs

4.4. Structs

4.5. Compact Classes

4.6. Functions

4.7. Delegates

5. Fundamentals of Binding a C Function

5.1. Out and Reference Parameters and Return Values

5.2. Ownership

5.3. Nullability

5.4. Static Methods

5.5. Changing the Position of Generated Arguments

5.6. Default Values and Changing an Argument's Position

5.7. Adapting a Signature with a Vala Wrapper

5.8. Variadic Arguments (a.k.a. "...")

5.9. Functions that Do Not Return

5.10. Methods that Change the Instance Reference

5.11. Methods that Destroy the Instance Reference

6. Adding Vala Friendly Semantics

6.1. to_string () Methods

6.2. Properties

6.3. Collections

7. Binding a C Function's Parameter and Return Types

7.1. Basic Types

7.2. Structs

7.3. Arrays

7.4. Strings and Buffers

7.5. Function Pointers

7.6. Parameters of Variable Type (Generics)

7.7. Pointers

8. Binding a C Struct's Fields

8.1. Structs

8.2. Pointers to Structs

8.3. Arrays

8.4. Function Pointers

8.5. Unions

9. Extra Hints

10. Awkward Situations

10.1. Array Lengths

10.2. Dependently Typed Ownership

10.3. Member Length

10.4. Owned Array of Unowned Objects

10.5. Shared Context Delegates

Design Patterns

1. Creational Design Patterns

2. Structural Design Patterns

3. Behavioral Design Patterns

4. 🚦 Wrap Up Folks

Memory Management

Documentation

Valadoc Guide

1. Quick Start

2. Command Line Tool

3. Documentation Comment Markup

3.1.1. Brief Description

3.1.2. Formatting

3.1.3. Taglets

3.1.4. Contributing to Valadoc

Vala for C# Programmers

Source Files

Compilation

Naming Conventions

Main Entry Point

System Namespace

Value Types

Verbatim String Literals

Documentation Comments

Object Base Class

Method Overloading

Multiple Constructors

Constructor Chaining

Delegates / Lambdas

Events

Interfaces

Enums

Struct Initialization

Multi-dimensional Arrays

Nullable Types

Code Attributes

Properties

Exceptions

Argument Checking

Unsafe Code and Pointers

Conditional Compilation Directives

Resource Disposing

Memory Management

Asynchronous Calls

Static Constructors

External Methods

Reflection

Not Available

Collections

Indexers

IO, Network Sockets

Console Input / Output

GTK+ Demo App

Bindings

Vala for Java Programmers

1. Project Setup and Toolchain

1.1. Source Files

1.2. Compilation

1.3. Using Libraries

1.4. Naming Conventions

1.5. Code Organization

1.6. Main Entry Point

2. Types and Core Syntax

2.1. Basic Types

2.2. Strings

2.3. Arrays

2.4. Type Inference

2.5. Foreach

3. Object-Oriented Programming

3.1. Inheritance

3.2. Object Base Class

3.3. Method Overloading

3.4. Multiple Constructors

3.5. Constructor Chaining

3.6. Overriding

3.7. Access Modifiers

3.8. Interfaces

3.9. Enums

3.10. Run-Time Type Information

3.11. Object Destruction

3.12. Annotations

4. Properties, Events, and Delegates

4.1. Properties

4.2. Delegates and Closures

4.3. Notification

4.4. Property Change Notification

5. Exceptions and API Contracts

5.1. Exceptions

5.2. Parameter Directions

5.3. Nullability

5.4. Argument Checking

6. Advanced Language and Runtime

6.1. Structs

6.2. Synchronizing

6.3. Conditional Compilation

6.4. Memory Management

6.5. Static Initialization

6.6. Varargs

6.7. Native Methods

6.8. Not Available

6.9. Features Not Covered in This Tutorial

7. Collections and I/O

7.1. Collections

7.2. IO, Network Sockets

7.3. Console Input / Output

8. From Swing to GTK+

8.1. From Swing to GTK+

Plugins

Type Modules

Libpeas

Syntax Guide

Sample Code

Language Features and Introductory Samples

Basic Samples

Intermediate Samples

String Sample

Character Sample

Signals and Callbacks

Properties Sample

Conditional Compilation Sample

Basics: Collections, Files, I/O, Networking, IPC

Vala Collections: libgee

List Sample

Set Sample

Map Example

Syntactic Sugar

Customizing the equality function

Iterable Sample

GIO Samples

GIO Compression Sample

GIO Settings Sample

GIO Networking Sample

D-Bus Basic (GDBus) Samples

D-Bus Client Examples

Async Method Samples

Testing Samples

Threading Samples

GTK4 Samples

Minimal App

Basic App

Synchronising Widgets

Text File Viewer

ListView

ListView with CheckButtons

ColumnView

Clipboard

Entry Completion with Two Cells

FAQ

On this page

3.5. Flow Analyzer

TODO

Add information about flow analyzer in Vala compiler

Feel free to help: Vala Docs Repository.

Last updated:

Pager

Previous page3.4. Symbol Resolution

Next page3.6. C Code Generation