BookLore: The Netflix of Books You Actually Own

Overview of this article

When I came across BookLore, I immediately wondered if this could be the solution to pulling together a plethora of documents I have accumulated over the years, scattered in folders, repositories and drives on my various computers.

There is no doubt that ongoing success with harnessing Open Source web server applications and putting them to serve my needs is growing at a rapid rate and whilst some have been challenging and others not as I had expected them to be, I now have media streaming, video servers, blogging sites and Podcast libraries that I can access from the Internet and all under my control, running independently of any sort of SaaS (Softwar as a Sevice) service provider or subsriptions. Yet, Booklore seemed to be a significant missing part of this collection in my jigsaw to independence.

The article replicated below, echoes my own sentiments about indepedence and in many ways it manifests that golden statement by Simon Sinek; “Lexicon to Conceptualise” in context of setting yourself free from chains of monopolies that have taken over our lives. In other words, the author of this article makes a clear and strong case about being on control of your own information and the pleasure of breaking the schakles placed around our ankles by technology giants or being patronised by some superior entity (in the sense that they are burning huge sums of Capital kill off the competition, leaving us the consumers with no other choice but to comply) and have a say over how we use, share and in some cases present our information. You would be surprised how many YouTube, TikTok, Instagram and Facebook Channels and Profiles are shut-down with little of no notice, simply because their Creators have somehow breached platform policy. In some cases by expressing compassion with people being subjected to War Crimes such as Palestinians in the Middle East!

As always, I have included a link to the original article at the bottom of this page if not only to pay due respect to the author but also as a way to track the author to see if he has other articles that may be of interest.

Attention

I have included the Script that installs BookLore as a Docker Container (LXC) on your Proxmox enironment but this article has been adopted because there are instructions further down that show how the application can be installed on a Ubuntu 24.04 OS. The Script described below is more like a Auto-installer and is not ideal for all use-cases.

Having my one Proxmox VE hypervisor, I installed this application on a Container using the Proxmox VE Communit-Scripts command, which makes life so simple that it is easy to make mistakes! What I mean by mistakes is that the Script can be for a specific system and environment and the installation may not necessary go as smoothly as you’d expect. In my case, accepting the DEFAULT settings during initial run of installation didn’t yield the results expected. I later deleted that original LXC Container and only got this right on my third attempt.

Even then, I noticed that after installation, the install-process went on for a long time with lot sof text appearing on the Console-screen. Reading some of these, I noticed that much of the downloaded and installed packages, Debian, Python and Perl Scripts among other were being updated – that is downloaded again and overwritten to ensure we had the latest verisons.

This goes to show that we can sometimes dive in blindly and accept what is thrown at us without realising that the Script we have just executed to install this application may have been written a long time ago and the packages pointed to may well have been superceded, hence a reiteration of installation process resulting in the setup to seemingly take forever.

If you are inclined and or curious, do take a look at the install-script, which is included below for convenience but is located on the www, click here to view the original (opens in new window)..

#!/usr/bin/env bash

# Copyright (c) 2021-2025 community-scripts ORG
# Author: MickLesk (CanbiZ)
# License: MIT | https://github.com/community-scripts/ProxmoxVE/raw/main/LICENSE
# Source: https://github.com/booklore-app/BookLore

source /dev/stdin <<<"$FUNCTIONS_FILE_PATH"
color
verb_ip6
catch_errors
setting_up_container
network_check
update_os

msg_info "Installing Dependencies"
$STD apt-get install -y nginx
msg_ok "Installed Dependencies"

fetch_and_deploy_gh_release "booklore" "booklore-app/BookLore"
JAVA_VERSION="21" setup_java
NODE_VERSION="22" setup_nodejs
setup_mariadb
setup_yq

msg_info "Setting up database"
DB_NAME=booklore_db
DB_USER=booklore_user
DB_PASS=$(openssl rand -base64 18 | tr -dc 'a-zA-Z0-9' | head -c13)
$STD mariadb -u root -e "CREATE DATABASE $DB_NAME;"
$STD mariadb -u root -e "CREATE USER '$DB_USER'@'localhost' IDENTIFIED BY '$DB_PASS';"
$STD mariadb -u root -e "GRANT ALL PRIVILEGES ON $DB_NAME.* TO '$DB_USER'@'localhost';"
$STD mariadb -u root -e "GRANT SELECT ON \`mysql\`.\`time_zone_name\` TO '$DB_USER'@'localhost'; FLUSH PRIVILEGES;"
{
  echo "BookLore Database Credentials"
  echo "Database: $DB_NAME"
  echo "Username: $DB_USER"
  echo "Password: $DB_PASS"
} >>~/booklore.creds
msg_ok "Set up database"

msg_info "Building Frontend"
cd /opt/booklore/booklore-ui
$STD npm install --force
$STD npm run build --configuration=production
msg_ok "Built Frontend"

msg_info "Creating Environment"
mkdir -p /opt/booklore_storage{/data,/books}
cat <<EOF >/opt/booklore_storage/.env
DATABASE_URL=jdbc:mariadb://localhost:3306/$DB_NAME
DATABASE_USERNAME=$DB_USER
DATABASE_PASSWORD=$DB_PASS
BOOKLORE_PORT=6060 

BOOKLORE_DATA_PATH=/opt/booklore_storage/data
BOOKLORE_BOOKS_PATH=/opt/booklore_storage/books
EOF
msg_ok "Created Environment"

msg_info "Building Backend"
cd /opt/booklore/booklore-api
APP_VERSION=$(curl -fsSL https://api.github.com/repos/booklore-app/BookLore/releases/latest | yq '.tag_name' | sed 's/^v//')
yq eval ".app.version = \"${APP_VERSION}\"" -i src/main/resources/application.yaml
$STD ./gradlew clean build --no-daemon
mkdir -p /opt/booklore/dist
JAR_PATH=$(find /opt/booklore/booklore-api/build/libs -maxdepth 1 -type f -name "booklore-api-*.jar" ! -name "*plain*" | head -n1)
if [[ -z "$JAR_PATH" ]]; then
  msg_error "Backend JAR not found"
  exit 1
fi
cp "$JAR_PATH" /opt/booklore/dist/app.jar
msg_ok "Built Backend"

msg_info "Configure Nginx"
rm -rf /usr/share/nginx/html
ln -s /opt/booklore/booklore-ui/dist/booklore/browser /usr/share/nginx/html
cp /opt/booklore/nginx.conf /etc/nginx/nginx.conf
sed -i "s/listen \${BOOKLORE_PORT};/listen 6060;/" /etc/nginx/nginx.conf
systemctl restart nginx
msg_ok "Configured Nginx"

msg_info "Creating Systemd Service"
cat <<EOF >/etc/systemd/system/booklore.service
[Unit]
Description=BookLore Java Service
After=network.target

[Service]
User=root
WorkingDirectory=/opt/booklore/dist
ExecStart=/usr/bin/java -jar /opt/booklore/dist/app.jar
EnvironmentFile=/opt/booklore_storage/.env
SuccessExitStatus=143
TimeoutStopSec=10
Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF
systemctl enable -q --now booklore
msg_ok "Created BookLore Service"

motd_ssh
customize

msg_info "Cleaning up"
$STD apt-get -y autoremove
$STD apt-get -y autoclean
msg_ok "Cleaned"

BookLore

BookLore delivers a lightning-fast, privacy-first, and fully open-source digital library experience—empowering you to host, organize, and explore your books without the lock-in, fees, or data risks of closed platforms.

Open Source Daily

21 Jun 20256 min

Digital library management has become essential to our reading lives. Yet most popular platforms—Kindle, Apple Books, Google Play Books—trade your privacy for convenience, lock your books behind proprietary walls, and charge recurring fees for features that should be standard. BookLore is here to change that. This open-source, self-hosted digital library puts you back in control, offering a beautifully modern, lightning-fast, and privacy-first way to manage your book collection—on your terms.

Why Choose BookLore?

In a landscape dominated by closed-source, cloud-based reading platforms, BookLore stands out with a radically different approach:

• Privacy First
  All your books and reading data are stored locally, never sent to corporate servers unless you choose. Your library remains yours—no data mining, no third-party analytics, no risk of books disappearing.
• Universal Format Support
  Read PDFs, EPUB files, and other eBook formats in a unified interface. Never worry about format compatibility or vendor-specific restrictions again.
• Advanced Reading Features
  Track reading progress, add bookmarks and highlights, take notes, and view detailed reading statistics. Build a comprehensive reading experience tailored to your habits.
• Powerful Library Management
  Organize books with custom metadata, tags, and collections. Search through your entire library instantly and discover forgotten gems in your collection.
• Modern Web Interface
  Built with Angular and Spring Boot, BookLore delivers a responsive, fast interface that works seamlessly across desktop, tablet, and mobile devices.
• Open Source & Forever Free
  No subscriptions, no DRM restrictions, no feature gating. All code is available under the GPL-3.0 license, with a growing community of book-loving contributors.
• Enterprise-Ready Authentication
  Support for OIDC/OAuth2, remote authentication, and trusted header SSO for seamless integration with existing systems.

Spotlight on Key Features

1. Comprehensive Book Management

• Support for PDF, EPUB, and multiple eBook formats
• Automatic metadata extraction and manual editing
• Custom tags, collections, and organizational systems
• Bulk import and library organization tools

2. Advanced Reading Experience

• Built-in PDF and eBook reader with progress tracking
• Bookmarks, highlights, and note-taking capabilities
• Reading statistics and progress analytics
• Responsive reading interface for all devices

3. Privacy & Data Ownership

• All books and data stored locally on your server
• No external dependencies or cloud synchronization
• Complete control over your reading data and statistics
• Export and backup capabilities for data portability

4. Modern Architecture & Integration

• Angular frontend with Spring Boot backend
• MariaDB database for robust data management
• Docker deployment for easy installation
• OIDC/OAuth2 and remote authentication support

5. Community-Driven Development

• 1,300+ GitHub stars and active development
• 7+ contributors and growing community
• Regular updates with new features and improvements
• Comprehensive documentation and setup guides

BookLore vs. Closed-Source Alternatives

How does BookLore compare to popular digital reading platforms? Here’s a side-by-side look:

Beyond the Feature Matrix

• No Vendor Lock-In: With BookLore, your books and reading data are always accessible, exportable, and portable—no proprietary formats or forced ecosystems.
• No Book Disappearance: Unlike cloud platforms, your books can’t be remotely removed due to licensing disputes or service changes.
• No Reading Surveillance: Your reading habits, preferences, and progress aren’t tracked for advertising or data mining purposes.
• No Format Restrictions: Read any supported format without conversion or compatibility worries across different devices.
• Complete Ownership: Your digital library truly belongs to you, with full control over organization, access, and sharing.

Getting Started in Minutes

BookLore is designed for effortless deployment with powerful features:

🐳 Docker Installation (Recommended)

# Docker Compose setup
version: '3.8'
services:
  booklore:
    image: adityachandelgit/booklore:latest
    container_name: booklore
    ports:
      - "8080:8080"
    volumes:
      - booklore_data:/app/data
      - ./books:/app/books
    environment:
      - SPRING_PROFILES_ACTIVE=docker

# Access at http://localhost:8080

💻 Manual Installation

# Requirements: Java 17+, Node.js 16+, MariaDB
git clone https://github.com/adityachandelgit/BookLore.git
cd BookLore

# Backend setup
cd backend
./gradlew build
java -jar build/libs/booklore.jar

# Frontend setup (separate terminal)
cd frontend
npm install
ng serve

🔐 Authentication Setup

Configure OIDC/OAuth2 or remote authentication for secure access:

# Environment variables for OIDC
OIDC_ENABLED=true
OIDC_CLIENT_ID=your-client-id
OIDC_CLIENT_SECRET=your-client-secret
OIDC_ISSUER_URI=https://your-provider.com

📚 Library Import

Upload your existing PDF and EPUB collections through the web interface or place them in the mounted books directory.

Real-World Success Stories

“I migrated my 500+ PDF collection from various cloud services to BookLore and finally have everything in one place. The reading progress tracking and note-taking features have transformed how I engage with technical documentation.”
— Dr. Sarah Martinez, Research Scientist

“BookLore replaced our departmental shared drive for academic papers. Students can now access the library from anywhere, track their reading progress, and collaborate on research notes.”
— Professor James Chen, University Library

“The self-hosted approach means our legal document library stays completely private while providing modern reading features. The OIDC integration with our existing authentication system was seamless.”
— Maria Rodriguez, Legal Technology Director

Practical Applications

Personal Digital Library

Organize your personal collection of PDFs, eBooks, and documents with advanced search, tagging, and reading progress tracking.

Academic & Research Libraries

Deploy for educational institutions to provide students and faculty with private access to academic papers, textbooks, and research materials.

Corporate Knowledge Management

Maintain internal documentation, training materials, and reference documents with secure access and reading analytics.

Family Reading Collections

Share books and reading progress across family members while maintaining privacy and control over your digital library.

Professional Development

Track technical documentation, industry reports, and professional reading with detailed analytics and note-taking capabilities.

Book Clubs & Reading Groups

Coordinate group reading with shared collections, progress tracking, and collaborative note-taking features.

Advanced Features & Architecture

BookLore implements modern web technologies for optimal performance and security:

Reading Experience

• Progressive Web App: Install as native app for offline reading
• Responsive Reader: Optimized for desktop, tablet, and mobile reading
• Reading Statistics: Detailed analytics on reading habits and progress
• Annotation System: Comprehensive highlighting and note-taking tools

Library Management

• Metadata Extraction: Automatic book information detection
• Custom Organization: Tags, collections, and custom categorization
• Search & Discovery: Full-text search across titles, authors, and content
• Bulk Operations: Efficient management of large book collections

Security & Authentication

• OIDC/OAuth2: Integration with Authentik, Authelia, and other providers
• Remote Authentication: Trusted header SSO and forward auth support
• User Management: Multi-user support with role-based access
• Session Security: Secure authentication with configurable timeouts

Enterprise Integration Benefits

BookLore seamlessly integrates with modern infrastructure and authentication systems:

Authentication Flexibility

• OIDC Providers: Works with Authentik, Authelia, Keycloak, and others
• Trusted Headers: Integration with reverse proxy authentication
• Forward Auth: Compatible with Traefik, Caddy, and NGINX auth modules
• User Provisioning: Automatic user creation from external authentication

Infrastructure Compatibility

• Docker Native: Optimized for containerized deployments
• Database Support: MariaDB backend for reliable data storage
• Reverse Proxy: Works behind NGINX, Traefik, Caddy, and others
• SSL/TLS: Full HTTPS support for secure access

Compliance & Privacy

• Data Residency: Complete control over where book data is stored
• GDPR Compliance: Privacy-by-design architecture
• Audit Trails: Comprehensive logging for access and usage
• Backup Control: Full control over backup and disaster recovery

Join the BookLore Community

With over 1,300 GitHub stars and active development, BookLore represents the future of self-hosted digital libraries:

• Contribute Code: Help enhance reading features and add new formats via GitHub
• Report Issues: Improve stability and user experience
• Feature Requests: Suggest new reading and library management features
• Documentation: Improve setup guides and user tutorials
• Translations: Help make BookLore accessible in more languages

The Future of Digital Reading

BookLore continues evolving with community-driven enhancements:

• Enhanced Formats: Support for more eBook formats and document types
• Advanced Analytics: Deeper insights into reading patterns and habits
• Collaboration Features: Enhanced sharing and group reading capabilities
• Mobile Apps: Native mobile applications for iOS and Android
• AI Integration: Smart recommendations and content analysis features

Final Thoughts

Your digital library is your intellectual sanctuary—don’t let it be controlled by corporate algorithms, DRM restrictions, or service shutdowns. BookLore represents a new era of digital reading: open, private, comprehensive, and truly yours. Whether you’re a researcher, student, professional, or passionate reader, BookLore offers a compelling alternative that puts you back in control of your reading experience.

Ready to reclaim your digital library? Explore the code on GitHub and start building your private reading sanctuary today.

Original article can be found here