The Tools Behind Static Libraries – gcc, ar, ranlib, and nm

UpdatedMarch 25, 2026

Heya! 👋 I love helping people, and one of the best ways I do this is by sharing my knowledge and experiences. My journey reflects the power of growth and transformation, and I’m here to document and share it with you.

I started as a pharmacist, practicing at a tertiary hospital in the Northern Region of Ghana. There, I saw firsthand the challenges in healthcare delivery and became fascinated by how technology could offer solutions. This sparked my interest in digital health, a field I believe holds the key to revolutionizing healthcare.

Determined to contribute, I taught myself programming, mastering tools like HTML, CSS, JavaScript, React, PHP, and more. But I craved deeper knowledge and practical experience. That’s when I joined the ALX Software Engineering program, which became a turning point. Spending over 70 hours a week learning, coding, and collaborating, I transitioned fully into tech.

Today, I am a Software Engineer and Digital Health Solutions Architect, building and contributing to innovative digital health solutions. I combine my healthcare expertise with technical skills to create impactful tools that solve real-world problems in health delivery.

Imposter syndrome has been part of my journey, but I’ve learned to embrace it as a sign of growth. Livestreaming my learning process, receiving feedback, and building in public have been crucial in overcoming self-doubt. Each experience has strengthened my belief in showing up, staying consistent, and growing through challenges.

Through this platform, I document my lessons, challenges, and successes to inspire and guide others—whether you’re transitioning careers, exploring digital health, or diving into software development.

I believe in accountability and the value of shared growth. Your feedback keeps me grounded and motivated to continue this journey. Let’s connect, learn, and grow together! 🚀

Comments

Join the discussion

No comments yet. Be the first to comment.

C Programming

Part 31 of 40

From today, I will be starting lessons on C programming in my ALX Software Engineering class and I look forward to sharing with you everything I learn through this series.

Up next

How Static Libraries Are Built (Step-by-Step Thinking)

In the previous lesson, we learned: What a static library is What a .a file contains How libraries are used in programs Now it’s time to understand something very important: How a static library

More from this blog

Choosing the Right AI Model for the Job

Imagine you have access to several AI models. One is extremely powerful but expensive. Another is fast and cheap but less capable. A third is excellent at coding but weaker at reasoning. Which on

Jun 16, 202610 min read

How Source Documents Make AI More Reliable

In the last lesson, you learned something important: AI can generate information that sounds convincing while still being completely wrong. That happens because AI primarily predicts patterns in langu

Jun 2, 20268 min read

Why AI Sounds Smart Even When It Is Wrong

One of the strangest things about modern AI is this: It can sound extremely intelligent while still being completely wrong. That is what makes AI both impressive and dangerous at the same time. You

Jun 2, 20269 min read

Prompt Engineering: Thinking Like a Professional AI User

At this point, you already understand something many AI users never fully realize: AI does not read prompts like humans do. It processes: tokens patterns structure and attention distribution Tha

May 30, 20268 min read

How AI actually processes your prompt under the hood

One of the biggest mistakes people make when using AI is assuming the AI reads like a human. It does not. Humans: infer meaning read between the lines fill in missing context guess intentions AI

May 30, 20268 min read

Dr. Ehoneah Obed

86 posts

Software engineer writing about systems: in code, in learning, in life. I reverse-engineer complex problems into frameworks. Pharmacist → SWE → Founder.

In the previous lesson, you learned the process of building a static library:

.c → .o → .a → program

Now we answer an important question:

What tools actually perform each of these steps?

In C (especially on UNIX systems), a few command-line tools work together to make this happen.

You don’t need to memorize everything.

Focus on understanding what each tool does.

1. The Big Picture

Each step in the library process is handled by a specific tool:

Step	Tool
Compile `.c` → `.o`	`gcc`
Bundle `.o` → `.a`	`ar`
Index the library	`ranlib`
Inspect contents	`nm`

Think of these tools as a team.

Each one has a specific role.

2. The Compiler: `gcc`

You’ve already used this.

gcc is responsible for:

Turning your .c files into .o object files.

Example idea:

file.c → file.o

What happens here:

Your code is converted into machine instructions
The file is not executable yet
It is only a piece of a program

Important idea:

gcc prepares your code for building, but does not finish the job.

3. The Archiver: `ar`

Once you have .o files, you need to bundle them.

This is where ar comes in.

ar is responsible for:

Creating a static library by grouping object files into a .a file.

So instead of:

file1.o
file2.o
file3.o

You get:

libsomething.a

Think of ar as a packaging tool.

It takes multiple compiled pieces and puts them into one container.

4. The Indexer: `ranlib`

After creating the library, we need to make it searchable.

This is the job of ranlib.

ranlib:

Builds an index inside the library so the compiler can quickly find functions.

Think of it like:

adding a table of contents to a book
making it easy to find specific chapters

Without this step, linking may fail or be inefficient.

5. The Inspector: `nm`

Sometimes you want to see what is inside a library.

This is where nm is useful.

nm:

Lists the symbols (functions and variables) inside object files or libraries.

It helps you answer questions like:

Does my function exist in the library?
Was it compiled correctly?
What functions are available?

Think of nm as a debugging and inspection tool.

6. How the Tools Work Together

Let’s connect everything:

Step 1: gcc → compile source files (.c → .o)

Step 2: ar → bundle object files (.o → .a)

Step 3: ranlib → index the library

Step 4: gcc → link library with program

Step 5: nm → inspect contents if needed

Each tool plays a role in the full pipeline.

7. A Simple Mental Model

You can think of the process like building a product:

Step	Analogy
gcc	Prepare parts
ar	Package parts
ranlib	Label contents
nm	Check contents

Together, they create something reusable.

8. Why You Should Understand These Tools

You don’t need to memorize all commands.

But understanding these tools helps you:

Debug problems
Understand compilation errors
Know what happens behind the scenes
Work more confidently in real projects

Most beginner confusion comes from not understanding what each tool does.

9. Common Beginner Confusions

❌ “Why do we need multiple tools?”

Because each tool does one specific job.

This keeps the system flexible and powerful.

❌ “Why not just use gcc for everything?”

gcc handles compilation and linking.

But bundling and indexing libraries require specialized tools.

❌ “Do I need to use nm every time?”

No.

It is mainly for debugging and inspection.

10. Practice Thinking (Before Coding)

Before you run any commands, think about this:

Which tool converts your code into machine instructions?
Which tool groups multiple object files together?
Why is indexing a library important?
When would you want to inspect the contents of a library?

Understanding these answers will make the actual commands much easier.

Key Ideas to Remember

gcc compiles your code
ar bundles object files into a library
ranlib makes the library searchable
nm lets you inspect what’s inside

Each tool has a clear and specific role.

What’s Next

In the next lesson, we will bring everything together by learning:

How to use a static library inside a program

You’ll see how your packaged functions become part of a working executable.

That’s where the full workflow finally connects.

Command Palette