A library is code your application calls when it needs a capability. A framework provides more of the application’s structure and commonly calls your code at defined points. The practical distinction is control flow: with a library, your code usually decides when to call it; with a framework, the framework often coordinates the flow and invokes your code.
How a library differs from a framework
A library is a reusable capability that an application can call. Your code decides when to use it and generally remains responsible for the application’s overall flow. Martin Fowler describes a library as “essentially a set of functions that you can call, these days usually organized into classes.” Fowler’s explanation of inversion of control sets out this distinction.
A framework offers a broader structure for building an application. You supply behavior at extension points—such as handlers or callbacks—and the framework calls that behavior as it runs the application. This reversal of who initiates the call is called inversion of control. Fowler calls it “a key part of what makes a framework different to a library.”
What inversion of control looks like
Imagine a task that must run when a particular event occurs. With a library, your application typically decides when the event-handling function should run and calls the library as part of its own flow. With a framework, you provide an event handler at the framework’s expected extension point; the framework decides when to invoke it.
Quick wins for a faster PC:
Repair Windows errors before they cause bigger problemsFix Now →Scan for outdated or missing drivers - takes under a minuteDriver Scan →#1 Best Overall
- Library: your application directs the sequence and calls the package when it needs its capability.
- Framework: the framework supplies more of the sequence and calls your code at defined hooks, handlers, or callbacks.
This is a rule of thumb, not a perfect classification test. Packages can combine roles, and the label alone does not tell you precisely how a particular package behaves.
What the distinction means in practice
Structure and responsibility
A library commonly focuses on a capability that an application can add to its own design. A framework typically gives the application a broader structure and expects developers to fill in parts of it. Django’s design philosophies, for example, describe a full-stack framework designed around loose coupling and reducing boilerplate. That is context for framework design; the key distinction remains who coordinates the program’s flow.
Extension points and organization
Frameworks define places where application behavior belongs, such as handlers, callbacks, hooks, or plugins. This can provide a coherent structure, but it also means the application must work within the framework’s conventions. Libraries are generally called where the application needs them, leaving more of the surrounding organization to the application.
They are not automatically substitutes
A library and a framework may solve different problems, so one is not inherently better. Compare candidates only when they address the same need, and examine what each actually does rather than relying on its label.
Rank #3
Examples: Angular libraries and Django
Angular’s documentation explains that libraries are imported and used in Angular applications, and names Angular Material as a general-purpose library. This illustrates how a framework ecosystem can include libraries that supply particular capabilities: the application can use those libraries without treating “library” and “framework” as mutually exclusive categories. See Angular’s overview of libraries.
Django is an example of a framework with a broader application-design role. Its documentation discusses design principles for a full-stack framework, including loose coupling and reducing boilerplate. The example is useful for understanding framework scope, but size alone does not make something a framework; control flow and how the package structures the application are more useful clues. See Django’s design philosophies.
How to classify a package you are considering
- Find out who starts the main flow. Does your application decide when to call the package, or does the package coordinate the lifecycle and invoke your code?
- Look for extension points. Check whether you provide handlers, callbacks, hooks, subclasses, or plugins for the package to call.
- Assess its scope. Does it provide a focused capability, or does it establish a broader structure for the application?
- Check how much organization remains yours. Consider how freely your application can arrange other components and whether the package expects you to follow particular conventions.
- Confirm the use case matches. If two packages do different jobs, calling one a framework and the other a library does not make them direct alternatives.
These questions are more useful than asking whether a package is “large enough” to count as a framework. A framework can include or work alongside libraries, and package labels are not universally consistent.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.The short answer
A library is generally called by your application; a framework generally provides more structure and calls your application’s code at extension points. Use that control-flow distinction to understand a package, while checking its actual scope and role in the particular application.
Quick Recap
Best Value
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
