Static Libraries
A static library is compiled code that can be later used when building an executable.
When the compiler makes an executable, the basic source files are first turned in to object files. The object files are then linked together to make an executable. When we compile source code, we don't necessarily have to make an executable. We could instead group all of the object files (made from sources) in to a single file called a static library.
The library is referred to as static, because when the object files which it contains are later linked in to an executable, a copy of all the needed code in the library is added to the executable.
Once the library is made, we can then use the code that it contains just as if we were compiling the source directly with our program.
Following is a simple example of creating a static library using these three files:

- `mylib.bas` - the source for the library
- `mylib.bi` - the header for the library
- `mytest.bas` - a test program

Our library will be a single module providing a single function:
`
'' mylib.bas
'' compile with: fbc -lib mylib.bas
'' Add two numbers together and return the result
Public Function Add2( ByVal x As Integer, ByVal y As Integer ) As Integer
Return( x + y )
End Function
`
Compile the library with:
`fbc -lib mylib.bas`
The -lib option tells the compiler to take the source code, `mylib.bas`, and turn it in to an object file `mylib.o`, then store the object file in to a library file, also called an archive, `libmylib.a`. A library might contain many modules (source files) each with many functions, but for this simple example, it is just one each.
To make use of the library in some other source code, we need some way of telling the compiler what exactly is in the library. A good way to do this is to put the declarations ( also called an interface, or API ) for the library in to a header file.
`
'' mylib.bi
#inclib "mylib"
Declare Function Add2( ByVal x As Integer, ByVal y As Integer ) As Integer
`
There is no need to compile the header. We want this in its source form so it can be included with other source files. The `#inclib` statement will tell the compiler the name of a static library that we need to link with when eventually making an executable.
With our library (.a file) and a header (.bi file) we can try them out in a test program:
`
'' mytest.bas
'' compile with: fbc mytest.bas
#include once "mylib.bi"
Print Add2(1,2)
`
The `#include` statement tells the compiler to include the source code from `mylib.bi` just as if we had typed it in to the original source. With the way we have written our include file, it tells the compiler everything it needs to know about the library.
We compile this with:
`fbc mytest.bas`
Then when we run the `mytest` executable, we should get the result of:
`3`
More than one source module can be used when making a library. And basic programs can use more than one library by including each needed header. Some libraries are so large that they might use several headers. On very large projects, making libraries out of some code modules that seldom change can improve compile times dramatically.
Libraries can optionally contain debugging information specified with the -g command line option.
Object files, and therefore libraries, are platform specific and in some cases specific to a particular version of the compiler and FreeBASIC runtime library.
See also

- Shared Libraries
- `#inclib`
- `#include`
- Compiler Option: -lib