Key Takeaways
Treat the web as a hypermedia system, not a JSON pipe
The web is a system. Hypermedia is content that carries controls for navigating or acting, such as HTML links and forms. A hypermedia system combines that format with a network protocol, a server that returns representations, and a client that knows how to present them. In the web, those pieces are HTML, HTTP, web servers, and browsers. The book calls applications built around these exchanges Hypermedia-Driven Applications, or HDAs.
REST means more than HTTP. Roy Fielding used REST to describe the web’s network architecture, where clients and servers communicate through hypermedia. A JSON response containing only data is not hypermedia: the client must already know what the fields mean and which endpoints to call. The authors argue that calling every HTTP-based JSON interface REST obscures this difference.
What's striking is that the disagreement is about where application knowledge lives, not whether JSON or HTML is fashionable. In a data API, the client carries a map of the domain and its operations. In a hypermedia system, the server sends a usable set of choices with the current representation. That distinction helps teams discuss architecture precisely. It also prevents a category error: HTTP alone does not make an API RESTful in Fielding's sense. The argument is strongest when applied to human-facing interfaces, not as a claim that data APIs are inherently misguided.
Let each server response reveal the actions available in the current state
Controls carry instructions. A hypermedia control describes an interaction, including where a request goes and how it should be made. In HTML, an anchor gives a destination for a GET, while a form specifies a target, a method, and values to submit. A browser can render and operate these controls without understanding the application's underlying concepts.
State travels with the interface. The book’s contact example makes the point concrete. An active contact representation offers an Archive action; once archived, it instead offers Unarchive. The HTML communicates both the contact’s displayed state and the action that makes sense now. A JSON client receiving only a status field must contain additional rules to infer those choices. This hypermedia principle is called HATEOAS: hypermedia acts as the engine of application state.
This design relocates change rather than eliminating it. The server can alter available actions and the client can continue to render them, reducing the need for coordinated client releases when workflows evolve. The browser succeeds because its job is deliberately general: interpret HTML, not understand contacts. The limitation is equally important. A hypermedia client must genuinely know how to interpret the format; a custom program expecting a fixed JSON schema cannot simply benefit from links it does not know how to use.
Use hypermedia for server-centered workflows, not every interface
Keep ordinary work ordinary. Contact.app is a familiar create, read, update, and delete application. Its value lies mostly in server-side data and rules, so links and forms provide a natural fit. With server-rendered HTML, the browser handles navigation, deep links, and the back button without a client-side router or a second domain model.
Spend complexity selectively. A spreadsheet is a different case: changing one cell can affect many others, possibly on every keystroke. Sending each change through a server round trip may be too slow, and the interface has no simple boundary around what needs updating. The authors recommend a rich client for that core behavior, while keeping straightforward features such as settings pages hypermedia-driven. A project has a limited complexity budget, so put the elaborate machinery where the task requires it.
The practical insight is architectural allocation, not a contest with one universal winner. A product can have a complicated core and many uncomplicated edges; treating every screen as equally demanding spends engineering effort badly. The spreadsheet example is a useful boundary test because it exposes how tightly coupled, rapid interactions differ from server-centered workflows. The same principle cautions against forcing hypermedia into an interaction merely to preserve ideological consistency. Simplicity is a property of the whole system, not of any single technology.
Use htmx to make HTML interactive without replacing its architecture
Extend the existing controls. Plain HTML limits server requests mainly to links and forms, and offers only GET and POST. The htmx library adds attributes that let other elements issue GET, POST, PUT, PATCH, or DELETE requests; choose events that trigger them; and target parts of the page for replacement. The response remains HTML, so the server still provides the interface rather than a JSON payload for client-side rendering.
Contact.app grows incrementally. htmx can turn navigation into background requests, validate an email as someone types, append results through click-to-load or infinite scrolling, and remove a deleted table row. It also supports browser history and request indicators. These additions deliver richer interaction while keeping server-rendered markup and HTTP exchanges at the center.
The library's central design choice is a small conceptual distance from HTML. Developers declare a request and a target in markup instead of building a parallel client model and rendering pipeline. That makes the interaction easier to inspect where it appears. The trade-off is that declarative attributes can still produce intricate behavior, particularly when many elements update one another. The approach reduces a category of complexity, but it does not make interaction design, accessibility, or testing optional.
Use HTTP methods and responses to describe what actually happened
Let the protocol do its job. GET retrieves a representation, while POST, PUT, PATCH, and DELETE express different kinds of changes. Plain HTML cannot directly issue every method, but htmx can, letting Contact.app delete a contact with DELETE on that contact’s URL instead of inventing a delete-specific path and sending POST.
Redirect codes matter. After a destructive request, a 303 response tells the client to retrieve the next page with GET. A 302 can preserve the original method, which would make a redirected DELETE remain a DELETE. The book also highlights HTTP caching through headers such as Cache-Control and Vary. If an endpoint returns different content depending on an htmx request header, Vary must identify that difference so cached full pages are not confused with partial responses.
Protocol semantics are useful because they make behavior legible beyond the code that happens to implement it. A DELETE request communicates intent, and a redirect code communicates what the client should do next. These conventions also reveal bugs that a framework may otherwise hide. The book's examples show that a seemingly minor response-code default can change the meaning of a whole interaction. Teams should still verify actual framework and client behavior, rather than assuming that standards language guarantees every implementation behaves identically.
Return only the interface fragment a user needs right now
Small responses can feel faster. In Contact.app, active search waits briefly after typing, then asks the server for matching contact rows. The server can return just those rows instead of a whole page. The debounce avoids issuing a request for every keystroke, and a request indicator tells the user when work is underway. The ordinary form still supports search without JavaScript, making the enhancement progressive.
Defer secondary work. The app’s total contact count can take up to a second and a half to calculate. Moving it to a separate endpoint and loading it after the main page lets users begin working sooner. The calculation has not become faster; its delay no longer blocks the primary task. The same pattern supports a long-running archive job: start it, poll for progress, then present a download link when complete.
These examples distinguish perceived responsiveness from raw completion time. A user can interact with the useful part of a page while secondary information arrives, and partial responses avoid rebuilding content that has not changed. The principle is less about making everything asynchronous than about deciding what must be ready first. Deferred work still consumes resources and can confuse users if its status is invisible, which is why the archive progress indicator and search spinner matter as much as the request itself.
Keep client scripts focused on interaction, not a second application model
Script without abandoning hypermedia. The book defines hypermedia-friendly scripting by two constraints: the main client-server format remains hypermedia, and state outside the DOM stays limited. Scripts can handle local interaction design, such as a menu, keyboard shortcut, or bulk-action toolbar, while the server retains business rules and presentation decisions.
Make behavior easy to find. Locality of Behavior means a reader should be able to see what an element does by inspecting its markup, without hunting through unrelated selectors and files. The book compares plain JavaScript, Alpine.js, and hyperscript as ways to add behavior near the relevant element. It also recommends events as a way to connect components without hard-coding direct dependencies. When a feature needs a large client-side model, a richer client architecture may be the better fit.
This is a more useful distinction than simply counting lines of JavaScript. A short script can still create a hidden client-side application, while a larger local interaction can remain subordinate to server-rendered hypermedia. The emphasis on locality makes code review and maintenance more concrete: behavior should be discoverable, and state should have an identifiable home. The approach also demands discipline. DOM state can become awkward for complex interactions, so minimizing external state should be a design goal, not a rule that overrides the actual needs of a feature.
Give JSON APIs a separate role instead of making one interface serve everyone
Different clients need different contracts. A browser can use a hypermedia API because it understands HTML and its controls. An automated import, a partner integration, or a mobile client without a hypermedia renderer may need structured data instead. The book recommends providing a JSON Data API for those uses rather than forcing them to parse HTML.
Let the contracts evolve differently. JSON clients usually depend on documented field names, endpoints, and behavior, so changes can require versioning and backward compatibility. A hypermedia interface can change its available links and forms as the server response changes. Contact.app keeps its JSON endpoints under a versioned path such as /api/v1, separate from the UI routes. Shared domain logic can remain in the model while each API has controllers and responses suited to its client.
Separating interfaces is not needless duplication if they solve different problems. A human-facing workflow benefits from a representation that embeds usable actions; a batch process benefits from predictable data structures. The crucial move is to share domain rules without pretending the clients have identical needs. This separation does introduce extra routes and testing obligations. It pays off when the team can keep those boundaries clear, rather than allowing a special-purpose UI endpoint to become an accidental public data contract.
Use mobile hypermedia when server control outweighs offline autonomy
Mobile can use server-rendered interfaces too. Hyperview is a mobile hypermedia system built around HXML, a format resembling XML, and a client for iOS and Android. Its responses describe mobile screens, controls, and behaviors. A server can define navigation, forms, list updates, and actions, rather than splitting the app's rules between a native client and a JSON API.
One model, tailored representations. The book ports Contact.app by reusing its Flask routes, domain model, and Jinja templates, while adding HXML templates for mobile. HTTP content negotiation can send HTML to a browser and HXML to Hyperview. The mobile client can also be extended with native actions and components, such as phone calls, email, messages, and swipeable rows. A single-purpose app binary still needs distribution through mobile app stores.
Hyperview shows that hypermedia is an architectural idea, not a synonym for browser pages. The server can remain the source of workflow logic while the representation respects a platform's navigation and interaction patterns. The ability to customize the client is important: server-driven does not mean every screen must look generic. However, the model depends on an available network and a suitable client. Offline-first behavior and highly dynamic local interfaces remain reasons to put more responsibility on the device.
Treat semantic HTML as a contract with browsers and assistive tools
Choose elements for their specified role. A generic div with a click handler does not automatically behave like a button: it may not receive keyboard focus, and assistive technology may not recognize its purpose. A real button provides built-in interaction semantics. HTML also helps browsers, screen readers, search engines, and other software understand the page.
Markup is not magic. The book warns against assuming that HTML is accessible by default. Custom tabs, menus, and other improvised controls need correct keyboard behavior and accessibility attributes, and incorrect semantic tags can mislead software. Use the HTML specification to choose elements, and test the result with keyboards and assistive technologies. When a purpose-built control or interaction library is safer, using it is better than avoiding JavaScript for its own sake.
The deeper lesson is that markup is an interface shared by several interpreters, not merely a styling scaffold for sighted users. Native elements provide behavior and meaning that custom controls must otherwise recreate. That makes semantic HTML a practical reliability strategy, not just a matter of code taste. At the same time, semantics cannot certify usability. A page can use correct tags and still have confusing focus order or poor interaction. The book's insistence on testing usefully qualifies any claim of accessibility by default.
Reserve thick-client logic for spreadsheets, offline apps, and similarly demanding interactions
Round trips have limits. Hypermedia works especially well when user actions have clear boundaries and the server can return the updated representation. A spreadsheet is a poor fit for that pattern when editing one cell can trigger cascading changes across the interface on every keystroke. The book identifies offline-first mobile apps as another weak fit because a server-rendered interface depends on connectivity.
Mix architectures deliberately. A complex application need not make one architectural choice for every screen. A spreadsheet-like editor may need a thick client, while account settings, help pages, or ordinary contact forms can remain hypermedia-driven. This division keeps the high-complexity client machinery focused on the parts that need it, instead of spreading it across the entire product.
This boundary matters because architectural debates often flatten distinct interaction patterns into one category called an app. The rate, locality, and dependency of state changes determine whether server exchanges are a natural fit. A hybrid system can be coherent if each boundary reflects a real difference in user needs, rather than being an arbitrary compromise. The challenge is operational: teams must define how the richer client and server-rendered areas exchange state. Choosing selectively reduces complexity only when those seams are designed and tested.
Analysis
The book’s most consequential move is to redefine the web application as a conversation between representations, rather than as a JavaScript interface that happens to use a browser. That shift changes the unit of design. Instead of asking how a client model maps to endpoints, developers ask whether a server response contains enough information for a general client to present the next available action. The Contact.app examples make this concrete: a small CRUD system gains search, partial updates, validation, polling, and mobile screens without making the client authoritative over the domain.
The strongest claim is not that hypermedia wins every comparison. It is that the default SPA architecture often spends complexity before the interaction requires it. Hypermedia reduces coordination demands for server-centered workflows and lets the server evolve a UI-specific API through the controls it returns. The book also avoids a false purity test by allowing scripting, separate data APIs, and thick clients where they earn their keep. This pragmatic boundary is essential to its argument.
There are real costs. Hypermedia depends on capable clients, and HTML’s native controls alone do not provide the interaction range users may expect. htmx closes much of that gap, but attributes, headers, event flows, caching, accessibility, and partial templates still require careful engineering. Likewise, server ownership centralizes useful logic but can make latency and server availability more visible. The mobile case adds a specialized client and format rather than removing client software entirely.
The lasting contribution is therefore a more precise architectural vocabulary. Hypermedia APIs serve people through clients that understand hypermedia; data APIs serve programs that expect data contracts. Applications can combine both. The useful question is not whether an app is modern enough for HTML, but where its state belongs, how quickly it changes, which clients consume it, and what complexity the team can sustain.
Review Summary
Hypermedia Systems receives mostly positive reviews, with readers praising its back-to-basics approach to web development. Many appreciate the book's critique of modern frameworks and its promotion of HTMX and hypermedia-driven applications. Readers find the concepts refreshing and applicable to real-world scenarios. Some criticism focuses on the complexity of larger applications and concerns about separation of concerns. The mobile development section receives mixed reactions. Overall, the book is seen as thought-provoking and potentially paradigm-shifting for web development.
People Also Read
Glossary
Hypermedia control
Embedded interaction instructionsAn element in a hypermedia representation that describes an interaction, often with a remote server, by encoding the details of that interaction within itself. HTML anchors and forms are examples: they provide destinations, methods, and, for forms, submitted values. A client can present these controls without understanding the application’s underlying data model.
Hypermedia-Driven Application
Application guided by hypermediaAn application that uses hypermedia and exchanges of hypermedia as its primary way to communicate with a server. Its client interprets the returned representation and the controls within it, rather than relying on a separate client-side model and data-only API as the main source of application behavior.
HATEOAS
Hypermedia drives application stateAn abbreviation for Hypermedia As The Engine of Application State. In this architectural constraint, the client discovers available actions through controls in server-provided representations. The client does not need prior knowledge of every endpoint or operation for each resource state; the hypermedia response indicates what actions are currently available.
htmx
HTML interaction extensionA JavaScript library that extends HTML with declarative attributes for issuing HTTP requests from elements, selecting triggering events, choosing request methods, and swapping returned HTML into targeted parts of a page. It is intended to enrich hypermedia interactions while retaining HTML responses and the web’s underlying client-server model.
Locality of Behavior
Behavior visible near its elementA software design principle in which the behavior of a unit of code should be apparent by inspecting that unit. In web interfaces, behavior should be discoverable near the markup for the relevant element, rather than requiring developers to trace distant selectors and event handlers. It does not require placing every implementation detail inline.
JSON Data API
Structured data interfaceAn API that returns structured domain data, commonly JSON, without embedding the hypermedia controls that describe available actions. Clients must know how to interpret fields and which endpoints to call, typically through prior documentation or coordinated implementation. Such APIs can suit scripts, integrations, and clients that do not render hypermedia.
HXML
Hyperview mobile formatThe XML-based hypermedia format used by Hyperview to describe mobile application screens, interface elements, and interactions. It includes mobile-oriented elements and declarative behaviors for navigation, updating content, and invoking system functions. Servers can render it with familiar templating techniques, while a Hyperview client interprets it on iOS or Android.
Hyperview
Mobile hypermedia systemAn open-source mobile hypermedia system comprising HXML, a client for iOS and Android, and extension points for custom elements and behavior actions. The server returns representations that define much of the mobile UI and its interactions. Developers can extend the client when an app needs native platform capabilities or specialized components.
Post/Redirect/Get
Redirect after form submissionA web interaction pattern in which a successful POST is followed by a redirect to a page retrieved with GET. This prevents a browser refresh from resubmitting the original form and accidentally repeating the mutation. The book also discusses using a 303 response after DELETE so the follow-up request uses GET.
HOWL stack
Hypermedia on any backendThe htmx community’s playful name for using hypermedia with whichever server-side language or framework suits the project. Since the browser communicates through HTTP and HTML, teams can choose a backend technology based on domain needs and expertise rather than adopting JavaScript on the server to match a JavaScript-heavy client.
FAQ
What is Hypermedia Systems by Carson Gross about?
- Core focus: The book explores how hypermedia, traditionally seen as document-centric, can serve as a powerful foundation for building modern, interactive web and mobile applications.
- Architectural emphasis: It highlights the full hypermedia architecture—covering HTML, HTTP, servers, and clients—and how these components interact to create flexible, RESTful applications.
- Modern relevance: Carson Gross argues that hypermedia-driven applications (HDAs) are not legacy but a sophisticated, competitive alternative to Single Page Applications (SPAs).
- Practical demonstration: The book uses real-world examples, such as building a contact management app, to ground its concepts in practical code.
Why should I read Hypermedia Systems by Carson Gross?
- Clarifies misconceptions: The book dispels the myth that hypermedia is outdated, showing its relevance for dynamic, complex applications.
- Practical guidance: It provides hands-on examples and step-by-step tutorials, including building and enhancing a contact management app with htmx and porting it to mobile with Hyperview.
- Alternative to SPAs: Gross presents hypermedia as a simpler, more maintainable, and secure alternative to heavy JavaScript frameworks and SPAs.
- Focus on simplicity: The book demonstrates how server-driven UI and minimal client-side scripting can reduce complexity and improve maintainability.
What are the key takeaways from Hypermedia Systems by Carson Gross?
- Hypermedia as modern architecture: Hypermedia is a robust, flexible, and modern approach to building web and mobile applications, not just a legacy technology.
- RESTful principles matter: True RESTful systems require hypermedia controls (HATEOAS), which many JSON APIs lack, leading to tighter coupling and more brittle applications.
- Tools for enhancement: Libraries like htmx and Hyperview can bring SPA-like interactivity to hypermedia-driven apps without sacrificing simplicity or RESTful design.
- Incremental improvement: Applications can be enhanced step-by-step, adding interactivity and advanced UI patterns while preserving the core hypermedia architecture.
How does Hypermedia Systems by Carson Gross define a hypermedia system and its components?
- RESTful foundation: A hypermedia system adheres to REST as described by Roy Fielding, using hypermedia controls to enable non-linear, dynamic interactions.
- Key components: It includes hypermedia formats (like HTML or HXML), network protocols (HTTP), servers presenting hypermedia APIs, and clients (browsers or mobile apps) that interpret responses.
- Distinction from JSON APIs: The book stresses that many so-called REST APIs are not truly RESTful unless they include hypermedia controls for navigation and interaction.
- Loose coupling: Hypermedia systems embed all necessary interaction information in responses, reducing the need for clients to have prior knowledge of the API.
How do Hypermedia-Driven Applications (HDAs) differ from Single Page Applications (SPAs) according to Carson Gross?
- Architectural contrast: HDAs use hypermedia as the engine of application state, exchanging HTML (or HXML) over HTTP, while SPAs rely on JavaScript and JSON APIs.
- Coupling and flexibility: HDAs avoid tight client-server coupling by embedding interaction logic in hypermedia, whereas SPAs require clients to know API structures in advance.
- User experience trade-offs: SPAs offer richer interactivity but introduce complexity and “JavaScript Fatigue,” while HDAs provide simplicity, robustness, and leverage browser features like caching.
- Maintainability: HDAs are more tolerant of API changes and easier to maintain due to their reliance on self-descriptive hypermedia responses.
What is htmx and how does it enhance HTML for building Hypermedia-Driven Applications, as described in Hypermedia Systems?
- Attribute-driven AJAX: htmx extends HTML with attributes (e.g., hx-get, hx-post, hx-trigger, hx-swap, hx-target) to declaratively specify AJAX requests and DOM updates without writing JavaScript.
- Overcoming HTML limitations: It allows any element to issue any HTTP method, be triggered by any event, and update parts of the page dynamically, addressing native HTML’s limited interactivity.
- Advanced features: htmx supports event filtering, request synchronization, out-of-band swaps, and CSS transition integration for smooth, dynamic UIs.
- Progressive enhancement: htmx preserves and extends HTML as hypermedia, enabling modern interactivity while maintaining RESTful and progressive enhancement principles.
How does Hypermedia Systems by Carson Gross explain REST and HATEOAS in the context of hypermedia?
- REST constraints: The book reviews Fielding’s REST constraints, emphasizing statelessness, caching, layered systems, and especially the uniform interface with hypermedia as the engine of application state (HATEOAS).
- Self-descriptive messages: RESTful responses must include all information (hypermedia controls) necessary for clients to navigate and interact without prior knowledge of the API.
- HATEOAS benefits: Hypermedia responses dynamically encode available actions, enabling clients to adapt to API changes without breaking, reducing versioning headaches common in JSON APIs.
- Loose coupling: This approach allows for more flexible, evolvable systems where clients and servers can change independently.
What practical example does Carson Gross use in Hypermedia Systems to demonstrate hypermedia-driven development?
- Contact.app: The book features a simple contact management web application built with Python, Flask, and Jinja2 templates, demonstrating CRUD operations using pure HTML hypermedia controls.
- Incremental enhancement: It shows how to progressively add interactivity with htmx, such as AJAX navigation, inline deletes, active search, lazy loading, and progress indicators.
- Educational value: This example grounds theoretical concepts in practical code, illustrating how hypermedia-driven applications can be built and improved step by step.
- Mobile extension: The app is also ported to mobile using Hyperview, demonstrating hypermedia’s versatility across platforms.
What are the key concepts of hypermedia-friendly scripting discussed in Hypermedia Systems?
- Scripting constraints: Scripting in HDAs should keep the main data format as hypermedia and minimize client-side state outside the DOM, ensuring business and presentation logic remain server-side.
- Scripting tools: The book covers Vanilla JavaScript (structured with RSJS), Alpine.js (declarative and reactive), and _hyperscript (English-like syntax focused on event handling) as compatible scripting options.
- Locality of behavior: Emphasizes embedding behavior declarations close to the HTML elements they affect, improving readability and maintainability.
- Contrast with traditional JS: This approach contrasts with the traditional separation of concerns, favoring proximity of markup and behavior for clarity.
How does Hypermedia Systems by Carson Gross apply hypermedia principles to native mobile app development with Hyperview?
- HXML format: Hyperview uses HXML, an XML-based hypermedia format inspired by HTML, to represent mobile UI elements, layouts, inputs, and behaviors declaratively.
- Client-server model: The Hyperview client (a React Native app) renders HXML screens fetched from the server, with all app logic and UI defined server-side, avoiding thick-client complexity.
- Extensibility: Hyperview supports custom UI elements and behavior actions, enabling deep platform integration and rich interactions while preserving the hypermedia-driven architecture.
- Consistency: This approach brings the benefits of hypermedia—loose coupling, flexibility, and maintainability—to native mobile development.
What advanced UI patterns and behaviors are implemented with htmx and Hyperview in Hypermedia Systems?
- Active Search: Implements search-as-you-type with debounced AJAX requests updating search results dynamically, improving UX without custom JavaScript.
- Lazy Loading: Defers loading expensive data (like total contact count) until needed, using htmx triggers for performance optimization.
- Inline and Bulk Delete: Enables deleting contacts directly from lists with confirmation dialogs, smooth fade-out animations, and bulk operations, all declaratively via htmx or HXML attributes.
- Mobile behaviors: Hyperview uses <behavior> elements to define triggers and actions (navigation, updates, system actions), enabling rich, decoupled mobile interactions.
What are the advantages and challenges of using Vanilla JavaScript and other scripting tools in Hypermedia-Driven Applications, according to Carson Gross?
- Advantages: VanillaJS requires no additional libraries, reduces complexity compared to SPA frameworks, and can be structured effectively using RSJS guidelines for maintainability and locality of behavior.
- Challenges: It lacks a default architectural style, can lead to “jQuery soup” with scattered event handlers, and DOM APIs are verbose and sometimes unintuitive.
- Best practices: Using data- attributes to invoke behavior and organizing code per component/file improves clarity and reuse, aligning VanillaJS with hypermedia-friendly scripting principles.
- Alternative tools: Alpine.js and _hyperscript offer more declarative, readable, and maintainable approaches for embedding behavior in hypermedia-driven apps.
What is the significance of Carson Gross’s message about the future of hypermedia in web development in Hypermedia Systems?
- Hypermedia resurgence: The book argues that hypermedia is a “great idea” with tremendous untapped potential and deserves renewed attention in modern web development.
- Call to action: Gross encourages developers to learn, build with, and advocate for hypermedia-driven architectures to challenge SPA dominance.
- Philosophical inspiration: Quoting Terminator 2, “The future is not set. There is no fate but what we make for ourselves,” the book inspires readers to shape the future of web architecture by embracing hypermedia.
- Vision for the web: The message is that developers have the power to create simpler, more robust, and maintainable systems by returning to and advancing hypermedia principles.
Download PDF
Download EPUB
.epub digital book format is ideal for reading ebooks on phones, tablets, and e-readers.