PixLab Blog

Blurry product photos and low-resolution campaign assets can interrupt an otherwise automated publishing workflow. Today, PixLab is expanding its image-processing toolkit with two new REST endpoints: the Image Deblur API and the Image Upscale API.

Developers can now add photo deblurring, image enhancement, and 2x upscaling to applications used by marketing teams, ecommerce businesses, creative agencies, and publishers. Upload an image or submit its public URL, then incorporate the processed result into your existing workflow.

Both endpoints are available starting with the Starter plan. Get your API key from the PixLab Console or compare PixLab plans and pricing.

Image Deblur API: Reduce Motion Blur in Photos

The PixLab Image Deblur API reduces motion blur and camera shake in photographs without changing their original dimensions. It is designed for workflows where a photo needs clearer detail, rather than a larger canvas.

Call the DEBLUR endpoint to process product photography, property listings, campaign images, or other photos in your application. No image mask, bounding box, or text prompt is required.

For marketing teams, this means adding a restoration step before reviewing event photography or lifestyle images for publication. Ecommerce platforms can apply the same process to blurred supplier photos, while real estate teams can prepare camera-shaken interior and exterior images for their listings.

Explore the Image Deblur API documentation and code examples for request parameters and integration details.

Image Upscale API: Enlarge Photos 2x or Enhance at Original Size

The PixLab Image Upscale API provides AI image enhancement and super-resolution through the UPSCALE endpoint.

• 2x upscaling: double the image's width and height while preserving its aspect ratio. A 1000 by 750 pixel image becomes 2000 by 1500 pixels.
• Original-size enhancement: use scale=1 to enhance an image without enlarging it.

The default scale=2 mode is useful when small product photos need to fit larger galleries or campaign layouts. Original-size enhancement is an alternative when your publishing workflow already has the dimensions it needs.

Unlike ordinary resizing, AI upscaling estimates additional detail from image patterns. It can create a clearer-looking enlargement, but it cannot guarantee recovery of information missing from the source.

See the Image Upscale API documentation for supported parameters, output options, and examples in Python, JavaScript, PHP, and Ruby.

Built for Marketing Teams, Ecommerce, and Creative Workflows

These endpoints fit into the systems your team already uses. Developers can integrate them into a product catalog, content management system, digital asset library, or custom photo-editing application.

• Marketing teams: prepare photography for social media posts, email newsletters, landing pages, and campaign updates.
• Ecommerce and marketplaces: process supplier and seller photos for product detail pages, catalog imports, and larger image galleries.
• Creative agencies: add deblurring or enhancement to client asset preparation before design and approval.
• Real estate and hospitality: improve the presentation of property and accommodation photos while retaining their proportions.
• Publishers and SaaS platforms: integrate image restoration and enlargement into editorial, upload, and editing workflows.

For bulk processing, submit one image per request and distribute work through your existing queue. Keep concurrency within your account's rate limits, and review important assets before publication. Contact PixLab to discuss sustained high-volume requirements.

Extend Your Existing PixLab Image-Processing Workflow

Deblurring and upscaling complement PixLab's existing image-cleanup endpoints:

• The Background Removal API isolates subjects and produces transparent cutouts for product listings, campaign compositions, and branded layouts.
• The Text and Watermark Removal API removes captions, labels, timestamps, and permitted watermarks from images you own or are authorized to modify.

Use each endpoint independently, or combine only the operations a particular asset needs. For example, an ecommerce application might enlarge a small product photo, while a marketing workflow might remove an outdated authorized text overlay before preparing new campaign copy.

Available Starting with the Starter Plan

You do not need an Enterprise subscription to get started. Image Deblur and Image Upscale are available from the PixLab Starter plan, with usage subject to your plan's allowance and account limits.

Review the PixLab pricing page to choose the plan that fits your workload. You can manage your API key and monitor usage in the PixLab Console.

Start Building

1. Sign in to the PixLab Console and get your API key.
2. Choose the Image Deblur API for motion blur, or the Image Upscale API for enlargement and enhancement.
3. Submit a representative image using a file upload or public URL.
4. Compare the result with the original, then integrate the endpoint into your application.

Image quality still depends on the source. Severe blur, heavy compression, and missing detail can limit restoration. Keep original files and review product labels, faces, logos, and fine textures before publishing processed images.

The new FACEIO website brings together updated developer documentation, localized pages, accessibility guidance, and dedicated product pages for facial authentication, Meeting Shield, and ID Match.

For website owners and businesses, it makes the options easier to understand. For developers, it provides a clearer path from creating a FACEIO application to integrating the fio.js JavaScript library and connecting authentication results to an existing backend.

Updated Documentation, From Your First Integration to Production

The documentation follows the work developers need to do: create an application, configure it, integrate the widget, and handle the results.

Start with Getting Started, our guide to a 5-minute facial authentication integration. It walks through creating an application in the FACEIO Console, obtaining its Public ID, reviewing the security and privacy settings, and adding fio.js to your website or web app.

Then use the Integration Guide for method parameters, return values, error codes, and framework examples. It covers enroll() for registering new users, authenticate() for returning users, and session handling with restartSession().

The Developer Center connects these resources with the references you need as your implementation grows:

• Facial ID reference: understand the identifier returned after enrollment and how to associate it with your own user accounts.
• REST API reference: manage Facial IDs and use the documented backend endpoints while keeping private API keys on your server.
• Webhook documentation: receive enrollment, authentication, and Facial ID deletion events in your backend.
• Security best practices: review PIN Code validation, liveness settings, domain restrictions, and the controls needed around your login flow.
• Privacy best practices: plan notices, consent, retention, deletion, and recognition-engine deployment.

Already using FACEIO? Revisit these references before your next release, especially if you are adding webhooks, changing security settings, or updating account-deletion workflows.

Read FACEIO in Your Language

The website and developer documentation are now available in four localized versions alongside English:

• Português do Brasil
• Español de México
• Bahasa Indonesia
• 日本語

Use the language selectors in the header or footer to move between equivalent pages. Technical names such as fio.js, Facial ID, API methods, and error constants remain unchanged so they stay consistent with the code you write.

Website localization is separate from the embedded experience: the FACEIO widget supports more than 70 languages, helping teams provide enrollment and authentication flows for users in different markets.

Facial Authentication for Websites, Web Apps, and Corporate Portals

FACEIO facial authentication remains the core of the platform. It lets users enroll and authenticate through a browser widget, using the device's camera without requiring a native mobile app or a dedicated biometric sensor.

Developers load fio.js, initialize it with the application's Public ID, and connect enrollment and authentication to their existing interface. The library works with Vanilla JavaScript, React, Vue, Next.js, and other JavaScript stacks.

Your backend keeps control of accounts, sessions, recovery, and authorization. FACEIO does not store, handle, or access biometric hashes; the selected facial recognition engine manages them. The updated documentation explains these responsibilities and the available cloud and PixLab Insight on-premises deployment options.

Meeting Shield: Video Risk Signals for Business Meetings

FACEIO Meeting Shield is a Chrome extension for supported Google Meet, Zoom Web, and Microsoft Teams Web sessions.

It analyzes visible meeting video and reports suspicious signals associated with deepfakes, synthetic video, replayed footage, and manipulated facial motion. Its local-first analysis is designed to avoid uploading raw meeting video.

Meeting Shield is intended for situations such as remote interviews, executive calls, financial consultations, and customer meetings. It gives teams additional information to review before sharing sensitive information or making a decision. These signals support the organization's verification process; they do not establish a participant's identity or guarantee that every manipulated video will be detected.

Visit the product page to review how the extension works and request access through the FACEIO Console.

ID Match: Compare a Live Selfie with an ID Portrait

FACEIO ID Match brings a guided selfie-to-ID comparison into your website or web app.

It uses the same application setup and fio.js integration pattern as facial authentication. Calling idmatch() opens a popup that captures a live selfie and an ID document, performs a liveness check, and compares the selfie with the portrait extracted from the document. Your application can also request selected document fields.

Document scanning, portrait extraction, and optional field extraction are powered by PixLab DOCSCAN. Submitted images and processing data are handled in RAM and deleted immediately after the result is ready or the session fails. The processing pipeline retains no submitted images, document data, or scan logs.

ID Match compares the two faces. It does not authenticate the document, perform KYC or AML checks, or decide whether to approve a user. Your application determines how to use the returned result and any requested fields.

Accessibility Is Part of the Integration

The updated website also explains the FACEIO widget's accessibility features: visual and audio instructions, keyboard navigation, and screen-reader support with compatible browsers and assistive technologies.

These features help guide users through enrollment and authentication. Before release, test the complete experience within your own website or web app and provide another way to access an account for users who cannot or do not want to use facial authentication.

Start with the New Guides

Whether you are adding passwordless face login to a customer website, integrating facial authentication into a corporate portal, or exploring Meeting Shield and ID Match, start with the product pages and updated documentation.

Open the FACEIO Console to create an application and obtain its Public ID, then follow the Getting Started guide to integrate fio.js.

For explanations and implementation articles, explore the FACEIO Knowledge Center. For public technical questions, join the FACEIO Community Forum.

At Symisc Systems, PixLab's parent company, we have taken on top engineering students from selective schools either remotely or on-site for their projets de fin d'études, or final-year projects. Some worked on embedded software in C/C++. Others worked on web development in vanilla JavaScript.

One striking pattern is how often even bright students struggle to write a complete, working function without returning to a chatbot for help.

Among the more than 20 students we observed, the tools in use were either ChatGPT or Z.ai's GLM models. Curiously, we did not see anyone using Anthropic's Claude. This was simply something we noticed while working with them, not a formal survey.

An assignment on our Think-Act Desktop Agent gives a good example of what concerned us.

A small dashboard task

A junior developer was asked to write an analytics function for the agent's internal usage dashboard. The task was to retrieve statistics stored as JSON in Redis through the backend and display them on the page using vanilla JavaScript.

He had a master's degree and was actively looking for a job.

During the implementation, he kept returning to his chatbot for elementary questions, including how to get an HTML element by its ID.

That meant looking up document.getElementById().

There is nothing wrong with forgetting a method name. We look things up every day, and using a chatbot for that is perfectly reasonable. What caught our attention was how much of the implementation depended on asking for the next step.

We expected him to need help with our codebase. But inspecting a JSON response, selecting an element and updating its contents should have been familiar enough for him to make progress independently.

Completing the assignment is only part of it

A student can follow a generated implementation and understand each line when it is explained. Writing a similar function from scratch can still be difficult.

The first attempt is where you have to make your own decisions. You inspect the input, decide what to do with it and discover what you misunderstood. Even a small function gives you practice that should make the next one easier.

When the chatbot supplies every step, it becomes harder to know how much of that practice is actually happening.

We build AI products ourselves. We see the usefulness of these tools, and there is no reason to ban them from an internship. But getting the work finished cannot be the only measure of a successful placement. The student should leave more capable than when they arrived.

A reasonable expectation

For a task like this, we think it is reasonable to ask a junior to make an initial attempt before requesting a generated solution. Read the documentation, inspect the response and try the implementation. Then use the chatbot to help with a specific difficulty.

Code review should include a conversation about the work. Ask the student to explain a condition, handle an empty response or make a small change. There is no need for a memory test or an interrogation.

A master's degree does not mean someone knows everything, and nobody expects a junior to work without help. But after implementing one dashboard function, they should be better equipped to write the next.

That is what we want to see: not whether they stop using the chatbot, but whether they need less guidance as they gain experience.

This is how we build our frontends

At PixLab, we use only vanilla JavaScript for frontend development. No React, no Vue. The same approach powers our customer dashboard, which serves thousands of customers, with a backend ingesting millions of real-time API usage records.

We had not removed a framework to make the assignment harder. He was working with the tools we use in production.

Customers rely on that dashboard to check usage for services such as our background removal API. Whether we are displaying those request counts or reviewing Think-Act activity internally, someone needs to understand how the data reaches the screen and why a number might be wrong.

That was the useful part of the assignment: following the data, writing the function and checking its behavior. It was also an opportunity to become comfortable with basic browser development.

Meet PixLab's Agentic AI Desktop Workspace

We are pleased to announce the release of Think-Act for Windows, our new agentic AI desktop workspace built to bring AI directly into everyday desktop workflows.

Think-Act is available now for 64-bit Windows 10 and Windows 11 with an upcoming release to Mac Silicon in first quarter of 2027 and can be downloaded directly from PixLab or Microsoft Store.

• Download Think-Act

Unlike a traditional AI chatbot that lives inside a browser tab, Think-Act is designed around the work already happening on your computer: documents, screenshots, selected text, recordings, files, and desktop applications.

The goal is simple: give users a practical AI workspace that can understand context, use tools, reason about multi-step tasks, and help complete real work without constantly moving information between unrelated applications.

An AI Agent Built for the Desktop

Think-Act combines several AI and productivity capabilities inside one Windows/Mac Native application.

The Desktop Agent can take a clearly defined task, work with the context you provide, use available tools and integrations, and coordinate multiple supported steps toward the requested result.

Instead of repeatedly copying information into an AI chat window, users can work directly with the material already in front of them.

Think-Act can use context such as:

• Local documents and PDFs
• Screenshots and images aided by built-in computer use tool
• Selected text from desktop applications
• OCR results
• Screen recordings and transcripts
• Files attached directly to a task
• Enabled local tools and integrations

This makes Think-Act useful for workflows that extend beyond simple question-and-answer interactions.

Writing Assistance Directly on Windows

Think-Act includes an integrated AI Writing Assistant for everyday writing tasks that is available system-side, and can be called from your everyday productivity software like Excel, Word, etc. using a global keyboard hot-key shortcut (defaulted to ALT+Space).

Users can select or provide text and ask Think-Act to:

• Rewrite content
• Improve clarity
• Summarize long text
• Translate content
• Change tone
• Structure rough notes
• Draft new material

The writing tools can be used independently without launching a full agent workflow.

• Explore Think-Act Writing Assistance

OCR and Document Intelligence

Documents are another major part of Think-Act Built-in OCR & Document Extraction capabilities.

The application can extract and analyze information from PDFs, screenshots, scans, and images using PixLab's document intelligence and OCR technologies.

Extracted information can then become context for another operation.

For example, a user can extract information from a scanned document and immediately use those results when preparing a summary, report, email, or agent task.

This keeps document processing and AI reasoning inside the same workflow.

Screen Recording and Workflow Context

Think-Act also includes screen recording capabilities.

A recorded desktop workflow can be converted into reusable context, documentation, or the starting point for another AI-assisted task.

This is particularly useful for:

• Recording procedures
• Creating internal documentation
• Capturing software issues
• Preparing tutorials
• Documenting recurring workflows
• Building reusable processes

Local Skills and MCP Integrations

Think-Act supports the Model Context Protocol (MCP) for connecting compatible local tools and services.

Users decide which connectors are installed and enabled.

Think-Act also supports reusable local Skills, allowing useful workflows and instructions to be saved and applied again when similar work appears.

Skills describe how a task should be approached, while connectors provide access to external tools.

Together, they allow Think-Act to move beyond a general AI assistant toward repeatable desktop automation.

• Explore Think-Act Integrations and MCP

Built Around User Control

Agentic software needs clear boundaries.

Think-Act is designed around explicit tool availability, permissions, reviewable execution, and approval controls.

Depending on the configured policy, an action can be:

• Allowed
• Sent to the user for approval
• Blocked

Users can inspect what happened during an agent workflow and review the final result before relying on it.

The objective is not to automate everything automatically.

It is to provide an AI desktop agent that can assist with meaningful work while keeping consequential actions under user control.

Think-Act for macOS Is Coming Next

Windows is only the beginning.

We are already developing a native macOS version of Think-Act, bringing the same desktop AI and agentic workflow experience to Mac users.

More information about the macOS release will be announced separately.

Download Think-Act for Windows

Think-Act is available now and free to install and try.

If your work regularly involves documents, writing, screenshots, OCR, desktop applications, repetitive processes, or multi-step AI tasks, Think-Act provides a new way to bring those capabilities together directly on your desktop.

• Download Think-Act: https://pixlab.io/think-act-desktop-agent/downloads
• Think-Act features: https://pixlab.io/think-act-desktop-agent/features
• Think-Act Desktop Agent: https://pixlab.io/think-act-desktop-agent/feature-desktop-agent

Welcome to Think-Act.

PixLab has rolled out a new production-ready version of its image and document automation stack, bringing major improvements to background removal, text watermark removal, and AI-powered document parsing.

This update introduces newer models, faster processing, improved accuracy, and a more robust production runtime for developers building high-volume image and document workflows.

What Is New

The upgraded PixLab APIs are designed to deliver better results with less operational friction:

• Faster background removal for product images, portraits, marketing assets, and user-generated content.
• More accurate text and watermark removal across complex image backgrounds.
• Improved handling of rotated, angled, and partially transparent text overlays.
• More reliable document parsing for PDFs and business documents.
• Production-hardened processing built for scalable API workloads.

These improvements are available through the existing PixLab developer experience, so teams can continue using the same documented endpoints while benefiting from the upgraded processing layer.

Background Removal API

The PixLab Background Removal API automatically isolates foreground subjects and returns a clean transparent PNG output. It is useful for ecommerce, profile photos, creative tools, media automation, and any workflow that needs fast object cutouts.

The new version improves both speed and mask quality, producing sharper foreground edges and more stable results across a wider range of image types.

Documentation: Background Remove API

Text Watermark Removal API

The PixLab Text Watermark Removal API removes visible text overlays and watermarks from images while preserving the surrounding visual context.

The upgraded models improve detection quality, especially for angled text, repeated watermarks, mixed backgrounds, and real-world image content where text may be partially transparent or blended into the scene.

Documentation: Text Watermark Remove API

Document Parse API

The PixLab LLM Parse API extracts structured content from documents and converts files into developer-friendly output formats. It is built for workflows such as document ingestion, OCR-assisted parsing, data extraction, search indexing, and AI document pipelines.

The new version improves parsing reliability and makes document processing easier to integrate into production systems.

Documentation: LLM Parse API

Built For Developers

PixLab APIs are designed to be simple to call, easy to integrate, and reliable under production workloads. Developers can test the upgraded APIs, manage credentials, and monitor usage directly from the PixLab Console.

World Lens is now live on the App Store for iPhone and iPad.

Built by PixLab Mobile Team, World Lens is a camera-first visual search app designed to help people understand the world around them faster. Point your camera at an unfamiliar object, a menu, a street sign, a landmark, a product label, or a printed page, and World Lens helps you identify, translate, read, and explore what you see in seconds.

This release brings together object recognition, text translation, read-aloud OCR, place recognition, QR scanning, and follow-up visual chat in one polished iOS experience. Instead of jumping between multiple apps for search, translation, camera scanning, and accessibility support, World Lens brings those real-world tasks into one flow.

Official Links

• World Lens on PixLab
• Download World Lens on the App Store

What World Lens Does

World Lens turns your iPhone camera into a practical visual assistant for everyday life, travel, accessibility, and quick discovery.

With World Lens, you can:

• Identify unknown objects around you
• Translate signs, menus, labels, and printed text
• Read real-world text aloud
• Recognize landmarks and nearby places
• Open supported place results in Maps
• Scan QR codes and supported barcodes
• Ask follow-up questions about what you just scanned
• Analyze both live camera captures and images from your gallery

The goal is simple: move from seeing to understanding with as little friction as possible.

Built for Real-World Visual Search

Many camera apps handle only one narrow task. One app scans QR codes. Another translates text. Another tries to identify objects. Another reads printed content aloud. World Lens was built to combine those common visual tasks into a single iPhone app that feels cohesive and fast.

That means you can use the same app whether you are trying to:

• figure out what an unfamiliar object is
• understand text in another language
• recognize a place while traveling
• read printed content more easily
• ask a follow-up question after a scan

World Lens is designed for the moments when you do not know exactly what you are looking at, what it says, or what to do next.

Key Features in the First App Store Release

Identify Unknown Objects

Point your camera at gadgets, tools, products, plants, signs, or everyday items and get fast, useful context. World Lens is built to help when keywords are unclear and manual search would slow you down.

Translate Text in Context

World Lens can translate text from menus, packaging, street signs, notices, labels, and printed pages. This makes it especially useful while traveling or navigating unfamiliar environments where speed matters.

Read Text Aloud

For users who want spoken assistance, World Lens can extract visible text and support read-aloud flows for signs, notices, labels, and printed material. This also makes the app more useful for accessibility-focused scenarios.

Recognize Places and Landmarks

World Lens can help identify nearby landmarks and places, then continue into Maps when supported. This makes it practical for city walks, tourism, local exploration, and everyday navigation.

Ask Follow-up Questions

A scan result is often only the start. World Lens includes scan-based chat so users can ask natural follow-up questions about what they just captured and get more context instead of stopping at a one-line answer.

Scan QR Codes and Barcodes

World Lens also covers fast utility scans. Open links from QR codes and detect supported barcodes without switching to a separate scanner app.

Use the Camera or the Gallery

The app is not limited to live capture. You can also analyze images from your photo library, which is useful when you want to revisit an image, check something later, or work from an existing screenshot or photo.

Why We Built World Lens

We built World Lens around a simple idea: visual understanding on mobile should feel more direct.

In everyday life, people constantly run into small moments of uncertainty:

• What is this object?
• What does this sign say?
• Is this a landmark or local place?
• Can I ask something more specific about what I just scanned?
• Can I get this text read aloud quickly?

These are common camera-driven tasks, but they are often spread across too many separate tools. World Lens brings them together into a single experience that feels practical instead of fragmented.

Who World Lens Is For

World Lens is useful for a wide range of users:

• Travelers who need help reading signs, menus, and labels
• Students who want to understand objects, places, and printed content faster
• Shoppers checking labels, packaging, and unknown products
• Explorers learning more about places and landmarks around them
• Accessibility-focused users who benefit from text reading and spoken output
• Curious users who want a faster way to identify things around them

This is not a niche utility. It is a general-purpose visual tool for real life.

Available Now on iPhone and iPad

World Lens is now available on the App Store for iPhone and iPad.

• World Lens product page on PixLab
• Download World Lens on the App Store

If you want a faster way to identify objects, translate text, understand places, read printed content aloud, and ask questions about what you see, World Lens is ready to use today.

What Comes Next

This App Store release is the foundation for World Lens. We will continue refining the experience, improving scan quality, expanding visual understanding flows, and making the app more useful across travel, accessibility, education, and everyday discovery.

For now, the focus is clear: make it easier to understand the world around you with your camera.

• Visit the World Lens PixLab page
• Get World Lens on the App Store

Symisc Systems is pleased to announce the immediate availability of UnQLite v1.2.1 – the latest stable release of the embedded NoSQL database engine.

What’s New

• Performance Boost – Up to 30% faster on key-value operations and document store queries.
• Reduced Memory Footprint – Optimized KV store engine lowers RAM usage by an average of 15%.
• New API: unqlite_kv_append() – Append binary data to existing keys without reading the whole value.
• Improved JSON Validation – Stricter schema checks when using the document store API.
• Bug Fixes – Addressed race conditions on concurrent reads in WAL mode and corrected cursor behavior after rollback.

Upgrading

UnQLite v1.2.1 is a drop-in replacement for v1.1.x. Simply drop the amalgamation build on your source tree and you are done. No further action are needed.

Full release notes are available on GitHub.

Why UnQLite?

For those new to the project: UnQLite is a self-contained, serverless NoSQL database that stores both key/value pairs and JSON documents. It runs in-process with zero configuration – ideal for mobile apps, IoT devices, and edge computing.

Get Involved

• GitHub Repository
• Documentation
• Issue Tracker

Upgrade today and let us know what you build with UnQLite!

The PixLab Mobile-Hub Team is pleased to announce the release of DocScan, PixLab’s all-in-one mobile document scanner for iPhone and iPad.

DocScan for iOS is built for people who need more than a basic camera capture. It helps you scan, read, structure, search, and reuse real-world documents directly from your mobile device. Whether you're working with handwritten notes, receipts, invoices, ID cards, menus, signs, or multi-page documents, DocScan for iOS turns raw scans into useful, structured output.

Download DocScan on the App Store

Scan, read, and use your documents faster

Most scanner apps stop after taking a picture. DocScan app goes further by understanding document content and helping you turn it into something actionable.

With DocScan for iOS, you can:

• Scan handwritten notes and turn them into searchable text
• Extract structured data from receipts and invoices
• Capture and enhance ID documents with dedicated scanning tools
• Use built-in document chat to ask questions about scanned pages
• Export results to PDF, Markdown, JSON, and CSV
• Build multi-page documents for archiving, sharing, or downstream workflows

Key features

Two-pass recognition

DocScan uses a two-pass recognition workflow. On-device OCR runs first for speed, then a cloud pass powered by DOCSCAN API improves difficult text when needed. This helps the app handle everything from rushed handwriting to noisy thermal receipts with better reliability.

Built-in document chat

Instead of reading through long pages manually, you can ask questions about what you scanned. Need a summary, a total amount, an expiration date, or a key detail from a contract or receipt? DocScan for iOS helps you get answers faster.

Handwriting scanning

DocScan for iOS is built to handle handwriting that basic OCR often misses, including cursive, shorthand, mixed scripts, and rushed writing. It is especially useful for notes, study material, research pages, and brainstorming sketches.

Receipt and invoice extraction

Thermal receipts and invoices rarely follow one format. DocScan for iOS extracts useful fields like vendor name, dates, totals, taxes, and line items so your scans are ready for accounting, reporting, or automation.

ID document capture

Passports, driver’s licenses, insurance cards, and other important documents need more than a simple photo. DocScan for iOS includes dedicated capture tools with glare reduction, edge detection, contrast tuning, and structured field extraction for cleaner results.

Signs, menus, and everyday document scanning

DocScan for iOS also works well on the go. Scan signs, notices, flyers, menus, and business cards, then search, translate, copy, or save the extracted content.

Flexible export formats

Scanned content should not stay trapped inside an app. DocScan supports export to:

• PDF
• Markdown
• JSON
• CSV

This makes it easier to archive scans, send them to teammates, move them into spreadsheets, or plug them into internal tools and automated workflows.

Built for real-world use

The DocScan mobile app is designed for people who work with documents every day, including:

• Students and researchers digitizing handwritten notes and study material
• Freelancers and small businesses capturing receipts, invoices, and contracts
• Travelers saving IDs and reading signs or menus abroad
• Developers and integrators building scanning and OCR into their own apps

Powered by the PixLab DOCSCAN API

One of the most important things about DocScan for iOS is that its scanning capabilities are powered by the PixLab DOCSCAN API.

That means the same engine behind the mobile app is also available to developers who want to add production-ready document scanning, OCR, KYC extraction, receipt ingestion, and structured document workflows to their own products.

If you’re building your own app, service, or internal platform, you can start integrating the same API that powers DocScan for iOS:

• DOCSCAN API: https://pixlab.io/id-scan-api/docscan

Available now

DocScan for iOS is now available on the App Store for iPhone and iPad.

• Homepage: https://pixlab.io/mobile-apps/docscan-app
• App Store: https://apps.apple.com/us/app/docscan-all-in-one-scanner/id6758423983

We built DocScan for iOS to make mobile document work faster, more intelligent, and more useful from the moment you capture a page. We’re excited to see how users and developers put it to work.

At PixLab and Symisc Systems, we build systems that move data between native C++ code and Python-based machine learning workflows. In practice, that often means dealing with NumPy array files.

Today, we are open-sourcing syNumpy, a standalone C++17 library for reading and writing NumPy .npy files.

syNumpy is designed to be simple to integrate, easy to understand, and reliable in production. It gives native applications a clean way to exchange numerical arrays with Python tooling without dragging in a heavy dependency stack.

Why We Built It

In computer vision, facial analysis, visual search, OCR, and document processing, moving tensors and feature vectors across systems is routine. NumPy’s .npy format is a practical interchange format, but using it directly from C++ often means either relying on outdated code, pulling in more infrastructure than needed, or maintaining internal glue code.

We wanted something better:

• modern C++17
• small and focused API surface
• easy vendoring into existing projects
• explicit validation and predictable failures
• production-ready .npy support without unnecessary complexity

That became syNumpy.

Production-Tested Inside FACEIO and PixLab

syNumpy is not a toy project or a throwaway utility. It is used internally by FACEIO for facial feature extraction workflows and by PixLab / Symisc Systems across production systems tied to visual search, document processing, and identity-document scanning.

That includes internal workflows behind:

• the DocScan Mobile App
• the PixLab API Endpoints
• the DOCSCAN API endpoint for scanning passports, driver licenses, visas, residence permits, and other identity documents issued around the world

That production use shaped the library directly. The goal was not to ship a bloated abstraction layer. The goal was to ship something dependable.

What syNumpy Provides

syNumpy focuses on doing one thing well: reading and writing NumPy .npy arrays from modern C++.

Current highlights include:

• support for NumPy .npy files
• a standalone C++17 implementation
• a compact API centered around:
  • syNumpy::NpyArray
  • syNumpy::loadNpyBuffer()
  • syNumpy::loadNpy()
  • syNumpy::saveNpyRaw()
  • typed syNumpy::saveNpy() overloads
• append mode support for compatible arrays
• strict validation of malformed headers and truncated payloads
• explicit runtime failures through syNumpy::Error

The core parser entry point is syNumpy::loadNpyBuffer(), which makes the library useful in embedded, memory-mapped, or network-driven workflows where the file is already available in memory.

Integration Is Intentionally Simple

One of the main design goals was frictionless integration.

The easiest way to use syNumpy is to add these two files directly to your codebase:

• synumpy.hpp
• synumpy.cpp

Compile them with your existing C++17 target and you are done.

No service layer. No code generator. No large runtime dependency stack.

The repository also includes a CMakeLists.txt and a simple Makefile, but the direct drop-in path is the intended fast path for most teams.

Minimal Example

#include "synumpy.hpp"
#include <vector>

int main() {
    std::vector<float> values = {1.0f, 2.0f, 3.0f};

    syNumpy::saveNpy("floats.npy", values);

    syNumpy::NpyArray arr = syNumpy::loadNpy("floats.npy");
    std::vector<float> roundtrip = arr.asVector<float>();

    return roundtrip.size() == 3 ? 0 : 1;
}

A Better Fit for Native ML and Vision Pipelines

There is a practical gap between Python-first tooling and production-grade native applications. syNumpy is meant to help close that gap.

If your system is already in C++, but your models, offline tooling, embeddings, or data-preparation steps live in Python and NumPy, having a straightforward .npy bridge matters. That is especially true in machine vision and identity workflows, where performance, reliability, and integration simplicity matter more than abstraction for abstraction’s sake.

Open Source and Licensing

syNumpy is released under the BSD 3-Clause License.

You can explore the project here:

• Project page: https://pixlab.io/numpy-cpp-library
• Source code: https://github.com/symisc/sy-numpy-cpp

Thoughts

We are releasing syNumpy because it solves a real problem we face in production, and because we think the wider C++ and machine vision community can benefit from a small, modern, well-scoped NumPy .npy library.

If you are building native AI, ML, OCR, document-analysis, or vision systems and need a direct bridge to NumPy arrays, syNumpy is built for exactly that use case.

PixLab's Online Video Editor backed by WASM/WebGPU & WebAudio technolgies has reached an important milestone. The app now delivers a much stronger browser-based editing experience with a cleaner interface, smoother playback, better text tools, and a growing visual effects stack designed for short-form video work.

This update focuses on the fundamentals that matter most when people are editing Reels, Shorts, stories, and other fast-turnaround videos. The result is a video editor that is easier to use, more reliable on the timeline, and much more capable for creators who want polished output without installing desktop software.

You can try the editor here:

• Open PixLab Video Editor
• Learn more on the landing page
• Read the tutorial

A Cleaner UI Built for Real Editing

The editing interface has been redesigned to reduce friction and keep the most important tasks obvious.

The current UI improvements include:

• a more polished workspace layout
• clearer separation between media, AI Studio, canvas, timeline, inspector, text, and effects
• a simpler path for importing video, making edits, and exporting
• a more focused right-side editing panel so text controls and effects no longer clutter the main inspector

The goal was straightforward: make it easier for a user to open a clip, make changes quickly, and export without fighting the interface.

New Text Overlay Workflow

Text overlays are now a real editing feature, not a basic add-on.

The editor now includes:

• a dedicated Text tab for overlay creation and editing
• direct text positioning on the canvas
• better text styling controls
• text background shapes
• transparent text background support
• stroke controls
• custom font upload
• live preview updates while editing

This makes PixLab much more useful for the kind of content people actually publish every day, including subtitles, hooks, lower thirds, title cards, and callout overlays.

Text Animation Presets

Text is no longer static by default. The editor now supports animation presets for overlays and captions, giving creators a faster way to add movement without manual keyframing.

Available animation presets include:

• Fade
• Pop In
• Bounce
• Slide Up
• Type On

These presets are especially useful for short-form video where timing, emphasis, and readability all matter in the first few seconds.

Custom Fonts for Brand and Style Control

PixLab Video Editor now supports local custom font uploads for text overlays.

That means creators can:

• use branded typography
• match client visual identity
• avoid being locked to a generic default font stack

Fonts stay local to the browser workflow and are tied into project persistence so users can continue editing with the same look and feel later.

New VFX and Effects Controls

The editor now includes a dedicated Effects workspace for clip-level visual adjustments and future VFX expansion.

The current effects set includes:

• brightness
• contrast
• saturation
• hue rotate
• blur
• sepia
• grayscale
• vignette
• sharpen

There are also quick presets for faster grading and look development:

• Clean
• Punchy
• Cinematic
• Noir

These effects are designed for practical video editing use cases rather than novelty. They help creators clean up footage, push style quickly, and get to a better result without leaving the browser.

Crop Controls for Social Video Framing

Basic crop controls are now included for video and image clips. This is important for adapting footage to short-form layouts and tighter compositions without forcing users into a full layout rebuild.

Combined with text overlays and canvas positioning, crop support makes it much easier to repurpose source footage for vertical and mobile-first formats.

A Better Timeline for Everyday Editing

The timeline has been significantly improved with a focus on simple, high-frequency actions.

Recent timeline improvements include:

• stronger trim behavior for clip starts and ends
• easier-to-grab trim handles
• a floating mini toolbar directly on selected clips
• trim start to playhead
• trim end to playhead
• split at playhead
• direct visual trimming on the timeline
• live trim feedback while dragging
• double-click edge trimming to the playhead

These changes make the most common cleanup tasks much easier, especially when removing the first few frames after hitting record or trimming the tail of a clip before export.

Linked Audio and Detach Audio Improvements

Audio handling on the timeline has also improved.

The editor now supports stronger linked clip behavior for video and detached audio, including:

• linked move
• linked trim
• linked split
• linked delete
• safer detach audio behavior

This helps the timeline behave more like a professional editor and reduces the friction of common editing operations where video and audio need to stay aligned.

Smoother Playback and More Reliable Canvas Preview

Playback was another major focus in this update. The canvas preview is now smoother, and audio playback is more stable thanks to better browser-side handling.

Behind the scenes, the editor now benefits from:

• improved media hydration when projects are reopened
• better handling of stored media assets
• smoother timeline updates during playback
• improved audio sync using a stronger playback path

This matters because creators need to trust what they see and hear before they export.

Export and Project Handling Improvements

The export path has been hardened so the editor behaves more reliably on real projects.

Recent improvements include:

• better asset persistence
• safer project save and reload behavior
• improved export handling for repeated media usage
• stronger frame seek behavior during export
• better handling of audio volume during export

These changes reduce the gap between preview and final output and make the editor safer to use on actual production work.

AI Studio Is Ready for the Next Phase

The AI Studio area in the interface is already in place and prepared for the upcoming backend integration. The current work has focused on making the core editor strong first, so that generated clips can drop into a workflow that already feels complete.

That means when AI video generation is fully connected, users will not be landing in a weak editor shell. They will be landing in a real browser-based video editor with text, effects, timeline controls, audio tools, and export already working together.

What This Update Means

This release is about maturity.

PixLab Online Video Editor is becoming a more capable short-form editing environment all for free with:

• better usability
• stronger playback
• improved export reliability
• richer text tools
• a dedicated effects pipeline
• cleaner editing workflows

If your work involves browser-based video editing, short-form content production, captions, overlays, or quick social edits, this update makes PixLab meaningfully more practical.

Try It

Open the app:

• https://video.pixlab.io/

Learn more:

• https://pixlab.io/ai-video-editor

Read the tutorial:

• https://pixlab.io/video-editor-tutorial

More updates are coming, including backend-powered AI generation and a stronger AI jobs workflow. For now, the core editing foundation is in much better shape and ready for the next phase.