DEV Community: Wiktor Wójcik

The Power of Elegant Simplicity #1: Shamir's Secret Sharing - The Polynomial That Guards Your Secrets

Wiktor Wójcik — Sat, 07 Feb 2026 23:00:00 +0000

Part of the “The Power of Elegant Simplicity” series - algorithms that hide power in plain sight

You know what’s wild? One of the most elegant cryptographic algorithms ever invented uses nothing more than high school algebra. No complex number theory, no quantum mechanics, just polynomials. The kind you probably learned to hate in 9th grade.

Welcome to Shamir’s Secret Sharing, where a simple quadratic equation becomes the foundation for securing nuclear launch codes, cryptocurrency wallets, and anything else you really, really don’t want falling into the wrong hands.

The Problem: Trust No One (But Trust Everyone Together)

Imagine you’re a startup founder with the keys to your company’s crypto wallet. If you keep them yourself, you’re one bike accident away from locking everyone out forever. If you give copies to your co-founders, any one of them could clean out the account and disappear to Bali.

What you need is a way to split a secret so that:

No single person can reconstruct it alone
But any group of, say, 3 out of 5 people can work together to recover it
People who don’t have enough shares learn absolutely nothing (not “almost nothing” - literally nothing)

This is exactly what Adi Shamir figured out in 1979. And the solution is beautifully simple.

The Trick: It’s Just a Polynomial

Here’s the entire algorithm in one sentence: encode your secret as a point on a polynomial, give each person a different point, and use the magic of polynomial interpolation to reconstruct it.

That’s it. No, really.

Let’s break it down with an example where we want 3 people to be able to reconstruct the secret, out of 6 total people (k=3, n=6).

Step 1: Encode Your Secret

Let’s say your secret is the number 8 (maybe it’s a password hash, or a piece of an encryption key).

Create a polynomial of degree k-1 (so degree 2 in our case) where the constant term is your secret:

f(x) = 3x² + 5x + 8

The coefficients 3 and 5? Completely random. Throw dice. Mash your keyboard. Doesn’t matter. But that 8? That’s your secret, hiding in plain sight at f(0).

Step 2: Generate the Shares

Now just evaluate your polynomial at different points:

def create_shares(secret, k, n):
    """ Split a secret into n shares where k shares are needed to reconstruct. Args: secret: The secret value to share k: Minimum number of shares needed to reconstruct n: Total number of shares to create """
    import random

    # Create a polynomial of degree k-1 with secret as constant term
    coefficients = [secret] + [random.randint(1, 100) for _ in range(k-1)]

    def polynomial(x):
        return sum(coef \* (x \*\* i) for i, coef in enumerate(coefficients))

    # Generate n shares by evaluating polynomial at different points
    shares = [(i, polynomial(i)) for i in range(1, n + 1)]
    return shares

# Example usage
secret = 8
shares = create_shares(secret, k=3, n=6)
# With coefficients [8, 5, 3] this gives us:
# [(1, 16), (2, 30), (3, 50), (4, 76), (5, 108), (6, 146)]

Give person #1 the point (1, 16), person #2 gets (2, 30), and so on. These are your shares.

Step 3: The Magic of Reconstruction

Here’s where it gets cool. With fewer than 3 shares, there are infinitely many polynomials that fit through those points. Just like two points define a line but could be part of any parabola, two shares from our 2nd-degree polynomial could match an infinite number of possible secrets.

But the moment you have 3 shares, boom - there’s exactly one polynomial of degree 2 that fits through all three points. Mathematics locks it in.

We use Lagrange interpolation to reconstruct the polynomial:

def lagrange_interpolation(shares):
    """ Reconstruct the secret using Lagrange interpolation. Args: shares: List of (x, y) tuples representing shares Returns: The secret (value at x=0) """
    def basis_polynomial(i, x):
        """Calculate the i-th Lagrange basis polynomial at x"""
        xi, yi = shares[i]
        result = yi

        for j, (xj, yj) in enumerate(shares):
            if i != j:
                result *= (x - xj) / (xi - xj)

        return result

    # Evaluate the interpolated polynomial at x=0 to get the secret
    secret = sum(basis\_polynomial(i, 0) for i in range(len(shares)))
    return round(secret)

# Reconstruct with any 3 shares
secret_recovered = lagrange_interpolation([(1, 16), (2, 30), (4, 76)])
print(f"Secret: {secret_recovered}") # Output: Secret: 8

The polynomial gets reconstructed, and f(0) gives us back our secret.

Why This is Actually Mind-Blowing

Perfect Security : If you have k-1 shares, you have zero information about the secret. Not “very little” - literally zero. The secret could be any value with equal probability. This is information-theoretic security, the same kind that makes one-time pads unbreakable.

Flexibility : Want to go from 5 shares to 10? Just evaluate the same polynomial at new points — instant new shares. Want to update the secret entirely? Generate a new polynomial and distribute fresh shares. One caveat: if you need to change the threshold (say, from “3 of 5” to “4 of 7”), that means a new polynomial of a different degree, so you’d need to redistribute all shares.

Simplicity : The entire algorithm fits in a tweet. Okay, maybe a long tweet. But still.

Real-World Applications

This isn’t just a clever party trick. Shamir’s Secret Sharing is used in:

Cryptocurrency wallets : Splitting recovery seeds across multiple devices or people
Certificate authorities : Requiring multiple executives to sign off on root certificates
Nuclear launch codes : Academic example because you definitely want more than one person to agree on this
Distributed password managers : Like Hashicorp Vault’s unseal process
Threshold signatures : Multiple parties cooperating to sign transactions

The Catch (There’s Always a Catch)

Like most cryptographic primitives, the devil is in the implementation details:

Random number generation matters : Those random coefficients need to come from a cryptographically secure random number generator (CSPRNG), like Python’s secrets module. The standard random module is a regular PRNG — predictable if someone knows the seed. (The code examples in this post use random for clarity, but don’t do that in production.)
Share storage is critical : Each share is as sensitive as the original secret. If someone gets k shares, game over.
No integrity protection (mostly): Basic Shamir doesn’t have built-in authentication, but here’s a neat trick — if you collect more than the minimum k shares, you can catch liars. Just try reconstructing from different subsets of k shares. If everyone’s honest, every subset gives the same secret. If someone faked their share, the subsets containing it will produce a different result, exposing the liar. Fair warning: this gets expensive fast (the number of subsets grows combinatorially), so it’s more of a sanity check than a scalable defense. For real-world use, look into verifiable schemes like Feldman’s VSS or Pedersen’s VSS.
Computation in finite fields : For production use, you need to work in finite fields (modulo a large prime) to avoid floating-point precision issues and information leakage.
Other production concerns : A full deployment would also want share authentication (MACs or signatures on each share), replay protection, and possibly proactive secret sharing — periodically refreshing shares without changing the secret. These are beyond our scope here, but worth knowing about if you ever build this for real.

The Modular Twist: From Theory to Practice

That last point deserves its own section, because it’s both important and surprisingly simple.

Everything I explained above works algebraically over the real numbers — the polynomial math is correct, and you’ll get your secret back. But here’s the thing: over ℝ, the scheme doesn’t actually provide information-theoretic security. The range and magnitude of the share values can leak information about the secret. The “zero knowledge with k-1 shares” guarantee only holds in a finite field. So modular arithmetic isn’t just a practical fix for computers — it’s a security requirement. Let me explain.

Why Modular Arithmetic?

Problem 1: Floating-point chaos

When you reconstruct a polynomial using Lagrange interpolation with real numbers, you’re doing lots of divisions. These create fractions that computers represent as floating-point numbers. After a few operations, you might get 7.999999999998 instead of 8. Usually you can just round, but what if your secret is 7 or 8? At scale, these errors compound.

Problem 2: Information leakage

Here’s a subtler issue. If someone has k-1 shares and sees the intermediate calculations, the size of those numbers might reveal information about the secret. In real arithmetic, evaluating a degree-2 polynomial at x=100 gives much bigger results for some coefficients than others. An attacker could use this to narrow down possibilities.

The solution: Work modulo a prime

Instead of doing arithmetic over all real numbers, we do everything modulo a large prime number p. This means:

All values stay in the range [0, p-1]
No floating-point numbers at all - everything is integers
Division becomes “multiplication by the modular inverse”
Every value is equally likely, revealing nothing

How Simple Is The Change?

Remarkably simple. Take any operation from the basic algorithm and add % prime at the end:

# Basic (problematic)
result = (result * x + coef)

# Modular (production-ready) 
result = (result * x + coef) % prime

The only tricky part is division. In modular arithmetic, you can’t just divide - instead, you multiply by the modular inverse. If you want to compute a / b mod p, you calculate a * (b^(-1)) mod p, where b^(-1) is the number such that b * b^(-1) ≡ 1 (mod p).

Python 3.8+ makes this trivial:

# Division in modular arithmetic
result = (a * pow(b, -1, prime)) % prime

That’s it. The entire conceptual framework - polynomials, shares, interpolation - stays exactly the same. You’re just doing the arithmetic in a different “universe” where numbers wrap around at prime.

Choosing Your Prime

The prime p needs to be larger than:

Your secret value
The number of shares you’ll create

A common choice is a Mersenne prime like 2³¹ - 1 or, for cryptographic applications, a 256-bit prime. The “Try It Yourself” example below uses modular arithmetic properly.

Try It Yourself

Here’s a complete, simple implementation you can play with:

import random

def create_shares(secret, k, n, prime=None):
    """Create n shares of a secret with threshold k"""
    if prime is None:
        prime = 2**31 - 1 # Mersenne prime for simplicity

    # Random coefficients for polynomial
    coefficients = [secret] + [random.randint(0, prime - 1) for _ in range(k - 1)]

    def evaluate(x):
        """Evaluate polynomial at x using Horner's method"""
        result = 0
        for coef in reversed(coefficients):
            result = (result * x + coef) % prime
        return result

    # Generate shares
    shares = [(i, evaluate(i)) for i in range(1, n + 1)]
    return shares, prime

def reconstruct_secret(shares, prime):
    """Reconstruct secret from shares using Lagrange interpolation"""
    secret = 0

    for i, (xi, yi) in enumerate(shares):
        numerator = denominator = 1

        for j, (xj, _) in enumerate(shares):
            if i != j:
                numerator = (numerator * (0 - xj)) % prime
                denominator = (denominator * (xi - xj)) % prime

        # Modular inverse for division in finite field
        lagrange_coef = (numerator \* pow(denominator, -1, prime)) % prime
        secret = (secret + yi * lagrange\_coef) % prime

    return secret

# Example
secret = 12345
shares, prime = create_shares(secret, k=3, n=5, prime=104729)
print(f"Original secret: {secret}")
print(f"Shares: {shares[:3]}") # Show first 3 shares

# Reconstruct with any 3 shares
recovered = reconstruct_secret(shares[:3], prime)
print(f"Recovered secret: {recovered}")

The Takeaway

Shamir’s Secret Sharing is sneakily brilliant because it looks so simple. Polynomials? We learned those in high school. But that simplicity hides incredible power: a mathematically perfect way to split trust, with security properties that hold up against even quantum computers.

Sometimes the best algorithms aren’t the most complex ones. Sometimes they’re the ones that make you slap your forehead and think, “why didn’t I think of that?”

That’s the beauty of elegantly simple algorithms. They hide in plain sight, doing impossible-seeming things with elementary mathematics.

Next in the series: Bloom Filters - The data structure that’s okay with being wrong (sometimes)

Further Reading:

Shamir’s original 1979 paper - Surprisingly readable
Implementation considerations for production systems
Example implementation: Secret Sharing Demo

Teaching Machines to Smell Danger: A Fun Dive Into ML-Powered Threat Detection

Wiktor Wójcik — Sat, 07 Feb 2026 23:00:00 +0000

Every now and then at Extiri, between shipping apps and squashing bugs, I like to take a detour into a completely different corner of tech — just to see what happens. At my university there was a statistics project that could be made so it served as ane xcuse to work wht ML. So this time, the question was: can I teach a machine learning model to sniff out network attacks? Spoiler: I got it to 97% accuracy, learned a ton, and had a surprisingly good time doing it.

Here’s how this little research adventure played out.

The Spark: Why Even Do This?

Network security is, at its heart, a massive pattern recognition puzzle. Attackers leave fingerprints everywhere — weird packet sizes, suspicious timing, oddly shaped data flows. The catch? These clues are buried under mountains of perfectly normal “someone’s watching YouTube” traffic, and they change all the time.

Classic rule-based systems are fine, but they’re a bit like a guard dog that only barks at people wearing the exact same hat as the last burglar. Machine learning, on the other hand, can learn the subtle statistical vibe of “everything’s fine” versus “something is definitely off.”

That sounded like a fun experiment. So I grabbed a dataset, fired up a Jupyter notebook, and went to work.

You can find all the code on GitHub if you want to follow along or poke holes in my methodology (feedback welcome!).

The Playground: 2.8 Million Network Flows

For data, I used the CICIDS 2017 dataset — a week-long capture of real network traffic where security researchers were actively staging different attacks alongside normal activity.

The numbers are huge: over 2.8 million network flows, each packed with features like:

Packet lengths and timing
Flow duration
Forward and backward packet statistics
Inter-arrival times

And the best part — every single flow is labeled as BENIGN or one of 14 different attack types (DDoS, Port Scan, SQL Injection… the whole villain roster).

Poking Around: The Detective Phase

Before letting any algorithm loose on the data, I wanted to actually understand what I was looking at. This turned out to be the most interesting part.

A Lopsided World

First fun fact: the dataset is overwhelmingly benign traffic. Which makes total sense — most real networks are boring most of the time. But it immediately means a model that just shrugs and says “looks fine to me” for every single packet would score high on accuracy while being spectacularly useless. Noted.

Which Features Actually Matter?

I ran correlations between every feature and the target variable to find out which network characteristics are the best attack detectors. Ten features rose to the top, including:

Backward packet length statistics (standard deviation, max, mean)
Packet length variance
Inter-arrival time patterns
Average packet sizes

Here’s where it gets nerdy (in a good way): these top features had massive standard deviations — some in the millions — and extreme positive skewness. In plain English? Most values huddle near zero, but there are wild outliers stretching way out into the distance. The data is leptokurtic, which is a word I don’t get to use nearly often enough.

It makes intuitive sense though. Normal browsing = small, regular packets. DDoS attack = a firehose of chaotic bursts.

Do Attacks Actually Look Different?

I plotted the distributions of these key features for benign vs. malicious traffic side by side, and — oh yes — the difference jumped right off the screen.

Benign traffic: smooth exponential decay, lots of tiny values, quickly tapering off. Malicious traffic: similar shape, but with telltale spikes at larger values. The attacks were basically wearing neon signs, statistically speaking.

But I didn’t want to just trust my eyeballs. So I ran Kolmogorov-Smirnov tests to compare the distributions formally. The p-values came back so close to zero that Python basically shrugged and said “yeah, these are not the same.” The benign and malicious features live in genuinely different statistical universes.

Green light. If the math says they’re different, machine learning should be able to find the boundary.

There was, however, a problem due to the both types - benign and malicious - having nearly identical spikes at the low end of the distribution. In those small-value ranges, benign and malicious traffic are practically indistinguishable — you’d need additional features (or deeper packet-level data) to tell them apart. I decided to accept that limitation and file it under “things to improve later.”

The Showdown: Four Models Enter, One Wins

Time for the fun part — the model bake-off. I trained four contenders:

Logistic Regression — the reliable baseline, the control group of ML
Random Forest — a whole crowd of decision trees voting together
Gradient Boosting — learns from its mistakes, one tree at a time
AdaBoost — keeps throwing more attention at the hard cases

All features were standardized first (mean 0, standard deviation 1), because some of those wild outliers would otherwise hijack the learning process. The data has been split into two sets - training and testing - so that I could test the model with data it has never seen. The sets used the “stratify” option to guarantee that each type of traffic will appear with the same proportions as the original.

The metric I cared about most? F1 score for the malicious class. In security, you’re always balancing two headaches:

Recall : Catch as many real attacks as possible (don’t let the bad guys through)
Precision : Don’t flood the security team with false alarms (the team might not be big enough)

F1 is the harmonic mean of both — one number that captures the trade-off nicely.

Results: And the Winner Is…

Model	Accuracy	Malicious F1	Malicious Precision	Malicious Recall
Random Forest	97%	0.92	0.99	0.87
Gradient Boosting	97%	0.91	0.98	0.84
AdaBoost	95%	0.86	0.95	0.79
Logistic Regression	89%	0.60	0.98	0.43

Random Forest took the crown with an F1 of 0.92. Some highlights:

99% precision on malicious traffic — when it says “attack,” it means it
100% recall on benign traffic — zero false truth on normal activity (!)
87% recall on malicious traffic — catches 87 out of every 100 attacks

That 13% miss rate is the price of keeping false truths at essentially zero. For many real-world setups, that’s a trade-off most security teams would happily take.

Why Did Random Forest Win?

Random Forests build hundreds of decision trees, each trained on a slightly different slice of the data, and then let them vote. It’s democracy applied to machine learning, and it turns out to be great at:

Wrangling high-dimensional data with complex interactions
Staying cool around outliers (those extreme values we found earlier)
Not overfitting, thanks to built-in regularization

Essentially, the model learned hundreds of different “if this packet looks like that, be suspicious” rules and combined them into one robust detector. Wisdom of the (tree) crowd.

Bonus Round: What Kind of Attack Is It?

Knowing “something’s wrong” is step one. But what exactly is wrong? That’s what security teams really need. So I trained a second Random Forest to classify the specific attack type — and it did surprisingly well:

99% overall accuracy
Perfect F1 scores (1.00) for attacks like FTP-Patator, Heartbleed, Infiltration, and PortScan
Near-perfect results on DDoS, DoS variants, and Bot traffic

But — and there’s always a but — web attacks gave it trouble. XSS landed at 0.36 F1, SQL Injection at 0.60, and Web Brute Force at 0.66. The model kept mixing them up, which actually makes sense: from a network-flow perspective, these attacks probably look pretty similar. To truly tell them apart, you’d need deeper packet inspection or application-layer features that this dataset doesn’t capture.

Where Could This Go?

This was a clean, controlled experiment. Taking it into the real world would mean tackling:

Continuous retraining as attack patterns evolve (attackers don’t stand still)
Adversarial robustness (what if someone deliberately tries to fool the model?)
Integration with actual security tooling
Explainability so humans understand why something got flagged

But as a proof of concept? A 97% accurate detector with 99% precision on malicious traffic is a pretty solid starting point — and a really enjoyable way to spend a few weekends.

All the code, statistical tests, confusion matrices, and model comparisons are available in the GitHub repo. Reproducibility or it didn’t happen.

Tools used : Python, Scikit-Learn, Pandas, Matplotlib, Seaborn

Dataset : CICIDS 2017 (2.8M network flows, 14 attack types)

Best model : Random Forest (F1: 0.92, Accuracy: 97%)

Introducing ClipGuru — a lightweight clipboard manager

Wiktor Wójcik — Fri, 17 Oct 2025 22:00:00 +0000

ClipGuru is a small, mobile-first clipboard manager built for iPhone and iPad. It solves a simple problem: when you copy something important on your device, you should be able to save it and find it again. Add clips quickly by tapping Paste inside the app or by typing a new clip — saved items are then easy to search and reuse. The macOS app complements the mobile experience for when you’re on a desktop.

We’ve all been there — on your phone or tablet you copy a quick link or quote, then later it’s gone because you copied something else. ClipGuru gives you a simple place to save those items: tap Paste in the app (or enter the content) to add it to your ClipGuru history. Once saved, clips are searchable and ready to reuse across your devices.

Who is ClipGuru for?

ClipGuru is for anyone who copies things a lot: writers, developers, designers, students, researchers, and people who simply like to keep small pieces of information handy.

Researching an article: copy quotes, links, facts, and find them later without opening dozens of tabs.
Design work: copy screenshots or small assets to reuse in presentations and mockups.
Multi-device workflow: copy on iPad, paste on Mac, continue your work uninterrupted.

What makes ClipGuru different?

Lightweight and focused: it does one job well — store and retrieve clipboard items.
Fast search: find past clips by keyword in seconds.
Multi-device friendly: saved clips sync across your devices via iCloud — add a clip on your iPhone or iPad and it will appear on your other devices (macOS included) shortly after.
Special keyboard: thanks to a custom keyboard you can access snippets anywhere you need.
Quick review: review your snippets and decide whether you want to keep or delete them without distractions

Find snippets quicker

Ever copied five different things in a row and needed the third one? ClipGuru helps you avoid clipboard roulette: paste items into the app as you go, then search by keyword to find them instantly. Results are fast and support simple filters so you can narrow results quickly.

Keep your favorites close

Some clips matter more than others — a signature line, a frequently shared link, or a small image you reuse. Pin those items to keep them at the top of your list so they’re one tap away when you need them.

Lightweight by design

ClipGuru intentionally avoids feature bloat. No complex tagging systems or heavy UIs — just a clean history, favorites, and fast search. It’s designed to help without getting in the way.

Room to grow

The initial release focuses on the essentials. We’ll add features based on feedback, but the core promise remains: a small, reliable place to save and find the clips you care about.

ClipGuru offers a simple, no-fuss approach to clipboard management. If you often copy things and want a reliable way to save and reuse them across devices, ClipGuru is built for that. Try it on your phone or tablet and see how it fits into your workflow.

We’re keeping the initial release simple and iterating based on feedback. If you have ideas or workflows you’d love ClipGuru to support, tell us — we’re listening.

ClipGuru is available on iPhone, iPad, and Mac. Try it and let your clipboard finally work for you.

For now, give it a try on your phone or tablet — see how it fits into your mobile workflow and let your clips work for you. ClipGuru stores text , links , and images that you add. Paste into the app (tap Paste) on iPhone or iPad to add a clip; saved clips sync via iCloud and will be available on your other devices, including the macOS companion app.

Because honestly, we’ve all got better things to do than hunt for that thing we copied five minutes ago.

Lets get started

Download ClipGuru from the App Store. The app is mobile-first (iPhone and iPad) but it’s also available on macOS. Learn more here.

From Theory to Practice: 5 Platforms That Turn Learning Into Doing

Wiktor Wójcik — Sun, 24 Aug 2025 22:00:00 +0000

Ever feel stuck in tutorial hell - watching endless videos but never actually applying what you learn? I’ve been there too. Books and courses are fantastic - they give structure, context, and explanations - but real understanding often comes when you actually do it.

Over time, I’ve discovered several platforms that take concepts from theory to hands-on experience. Each one is free and ready to help you practice and internalize what you learn.

1. CryptoHack – Experiment with Cryptography

Cryptography has always fascinated me. Recently, I wanted a way to practice it beyond reading theory, and that’s when I found CryptoHack.

CryptoHack offers challenges that let you experiment directly with cryptographic algorithms. From XOR operations to RSA attacks, you get to see how the theory works in practice. They also have structured introductory courses if you want guided learning.

Explore CryptoHack

2. iximiuz Labs – Hands-On DevOps

I often learn Linux or Docker from blogs or books - but the moment it clicks is when I actually spin it up. That’s where iximiuz Labs comes in.

This platform provides practical challenges in Linux, Docker, and Kubernetes. Each challenge is designed to let you solve real-world tasks, deepening your understanding of the concepts while keeping it safe in a sandboxed environment.

Try iximiuz Labs

3. Deep-ML – Understand Machine Learning From the Inside

Reading about PCA, neural networks, or gradient descent is one thing - but implementing them yourself is where understanding solidifies.

Deep-ML offers machine learning and deep learning challenges crafted to make you code the algorithms yourself. It’s a structured playground that helps you see how the math and theory translate into real computation.

Start with Deep-ML

4. WebGPU Puzzles – Feel Parallel Execution

GPU programming can feel abstract until you run code yourself. WebGPU Puzzles brings WGSL coding directly to your browser, no installation required.

Through small compute puzzles, you dispatch GPU threads and see parallel execution in action. It’s a surprisingly intuitive way to get a tactile feel for GPU computing fundamentals.

Explore WebGPU Puzzles

5. Project Euler – Sharpen Your Mathematical Thinking

Reading about algorithms is useful - but solving them is transformative.

Project Euler offers small, elegant math-and-programming problems that make you think algorithmically. I use it especially to train my mathematical thinking, and each solved problem feels like a small victory that reinforces the concepts I’ve learned.

Try Project Euler

Hands-On Learning Matters

Books, blogs, and courses give you the foundation. Hands-on practice turns that knowledge into skill. These platforms have helped me solidify concepts, see results instantly, and stay motivated by giving tangible accomplishments along the way.

I hope they do the same for you. Dive in, experiment, fail, fix, and learn - your brain will thank you.

Some snippets of code for your Swift apps

Wiktor Wójcik — Wed, 02 Oct 2024 22:00:00 +0000

Hi! While programming in Swift I have accumulated many code snippets. Some of them are mine and some of them come from the internet. Here I’m sharing 5 tiny quality-of-life snippets. Hopefully you will find them useful.

1. (Cocoa) Accessing NSWindow from NSViewController

extension NSViewController {
  var window: NSWindow? {
    for window in NSApp.windows {
      if window.contentViewController == self {
        return window
      }
    }
    return nil
  }
}

This snippet adds a window variable to NSViewController. It requires the window to exist (eg. be in NSApp.windows, in most cases that will be true) and that there is only one window with the specified view controller. It will return the window with the view controller on which it is called.

2. Checking if path leads to a directory

extension FileManager {
  func isDirectory(path: String) -> Bool {
    var isDirectory: ObjCBool = false
    self.fileExists(atPath: path, isDirectory: &isDirectory)
    return isDirectory.boolValue
  }
}

This is a simple wrapper around FileManager.fileExists() as an extension to FileManager that checks whether a path provided as a string leads to a directory.

3. Safely accessing an array

extension Array {
    subscript(safely index: Int) -> Element? {
        if index < self.endIndex && index >= 0 {
            return self[index]
        } else {
            return nil
        }
    }
}

This snippet adds a subscript to arrays. It checks whether index is within the array’s range then returns an element or nil depending on the check. You can use it like this:

let array = ["a", "b", "c"]
let value = array[safely: 2] // returns Optional("c")

This might save you few lines of code for checking and force you to handle the edge case without crashing the app.

4. (SwiftUI) Web view wrapper

struct WebView: NSViewRepresentable {
    /// URL of current page. If changed, WebView will change it into the new URL.
    @Binding var url: URL

    private var onLoadStart: (WKWebView) -> ()
    private var onLoadFinish: (WKWebView) -> ()

  /// A WKWebView instance, which is used to render WebView, and which can be used to control it thanks to classes being passed by reference.
    private var wkWebView: WKWebView

  /// Accepts a binding to an URL, WKWebView instance, which can be used to control WebView and onLoadStart and onLoadFinish which will run when WebView starts or finishes loading a webpage.
    init(url: Binding<URL>, wkWebView: WKWebView = WKWebView(), onLoadStart: ((WKWebView) -> ())? = nil, onLoadFinish: ((WKWebView) -> ())? = nil) {
        self.wkWebView = wkWebView

        self.\_url = url

        if let onLoadStart = onLoadStart {
            self.onLoadStart = onLoadStart
        } else {
            self.onLoadStart = { \_ in }
        }

        if let onLoadFinish = onLoadFinish {
            self.onLoadFinish = onLoadFinish
        } else {
            self.onLoadFinish = { \_ in }
        }
    }

    func makeNSView(context: Context) -> WKWebView {
        wkWebView.navigationDelegate = context.coordinator
        wkWebView.load(URLRequest(url: url))

        return wkWebView
    }

    func updateNSView(\_ nsView: WKWebView, context: Context) {
        nsView.load(URLRequest(url: url))
    }

    func makeCoordinator() -> Coordinator {
        Coordinator(onLoadStart: onLoadStart, onLoadFinish: onLoadFinish)
    }

    class Coordinator: NSObject, WKNavigationDelegate {
        let onLoadStart: (WKWebView) -> ()
        let onLoadFinish: (WKWebView) -> ()

        init(onLoadStart: @escaping (WKWebView) -> (), onLoadFinish: @escaping (WKWebView) -> ()) {
            self.onLoadStart = onLoadStart
            self.onLoadFinish = onLoadFinish
        }

        func webView(\_ webView: WKWebView, didCommit navigation: WKNavigation!) {
            onLoadStart(webView)
        }

        func webView(\_ webView: WKWebView, didFinish navigation: WKNavigation!) {
            onLoadFinish(webView)
        }
    }
}

This pretty lengthy snippet adds a simple SwiftUI wrapper around WKWebView (which needs to be imported). It only requires a binding to a url, which will be loaded. In more complex cases, you can pass onLoadStart and onLoadFinish handlers which will run when the web view starts and finishes loading and a WKWebView class instance. Since in Swift classes are passed by reference, you can use this instance in your view to control the web view (go back, forward, etc).

5. (Cocoa) Showing an alert

func showAlert(message: String, informative: String, buttons: [String] = [], completionHandler: @escaping (NSApplication.ModalResponse) -> () = { \_ in }) {
    DispatchQueue.main.async {
        let alert = NSAlert()

        alert.messageText = message
        alert.informativeText = informative

        buttons.forEach { alert.addButton(withTitle: $0) }

        let result = alert.runModal()
        completionHandler(result)
    }
}

Once again, a wrapper. It wraps NSAlert in one function so that you don’t need to rewrite this code. It accepts a message and informative text which will be used on the alert. It also optionally accepts a list of button titles which will be added to the alert. It also runs asynchronously on the main thread, so it works even when run in another thread. Here I’d like to add that you can use NSAlert.accessoryView to create alerts with custom views, for example I did something like this:

func showChoicePrompt(message: String, informativeText: String, buttons: [String], completionHandler: @escaping (String?) -> Void) {
  let alert = NSAlert()

  alert.addButton(withTitle: "OK")
  alert.addButton(withTitle: "Cancel")

  alert.messageText = message
  alert.informativeText = informativeText

  let popUp = NSPopUpButton(frame: NSRect(x: 0, y: 0, width: 200, height: 24))
  popUp.addItems(withTitles: buttons)

  alert.accessoryView = popUp

  let response: NSApplication.ModalResponse = alert.runModal()

  if response == NSApplication.ModalResponse.alertFirstButtonReturn {
    completionHandler(popUp.selectedItem?.title)
  } else {
    completionHandler(nil)
  }
}

which creates an alert with a pop up button for selecting a value.

As a sidenote, if you are dealing with many snippets of various types (like these ones), CodeMenu can help you organize, access and use their full potential.

Taking an image of a part of the screen in a Cocoa app

Wiktor Wójcik — Fri, 20 Sep 2024 22:00:00 +0000

Hi! In this post I will show you how to write a “screenshot taker” for a Cocoa app. It will allow the user to select a part of the screen, just like the builtin screenshot taking tool on macOS. It uses CGWindowListCreateImage (macOS 10.5 - 14.0), so it should work in old codebases although it’s important to note that it’s deprecated in macOS 14.0. In such case you should use ScreenCaptureKit and it’s functions like captureScreenshot. It should work well for most cases. Well, let’s start!

This code will be pretty lengthy so I will split it into two parts: a manager and a view controller. The manager will be the frontend for screenshot taking and the view controller will be responsible for selecting part of the screen. Let’s begin with the manager.

Manager

class ScreenshotManager {
    private static var windowController: NSWindowController? = nil
    private static var isRunning = false
    static var completionHandler: (Result<NSImage, Error>) -> Void = { \_ in }

    enum SMError: Error {
        case failedToTakeScreenshot
        case noSelection
        case alreadyInUse
        case noPermission
        case noAccessToScreen
    }
}

First we define the ScreenshotManager class in which we define the variables and the error type. windowController stores the window controller for selection window, isRunning contains information whether screenshot is already being taken and completionHandler contains a handler that will be called when the user stops selecting or an error happens while selecting. I will use static functions and variables because only one screenshot-taking can happen at a time. Now we will add a function for taking a screenshot from a part of the screen.

class ScreenshotManager {
...
    @MainActor
    static func take(frame: NSRect) throws -> NSImage {
        isRunning = false

        let cgRect = CGRect(x: frame.origin.x, y: frame.origin.y, width: frame.width, height: frame.height)
        guard let screenshot = CGWindowListCreateImage(cgRect, .optionOnScreenOnly, .zero, []) else {
          throw SMError.failedToTakeScreenshot

        }

        return NSImage(cgImage: screenshot, size: .init(width: screenshot.width, height: screenshot.height))
      }
}

This function receives a frame with the information about the selection’s size and position. Since CGWindowListCreateImage needs CGRect, we crate cgRect from the frame. .optionOnScreenOnly means that the image will contain only the visible windows and as the fourth parameter we provide an empty array since we don’t need any additional options. .zero is used a reference window ID, but I’m not sure what it means, but I works. Then, we convert the resulting image (screenshot) into an NSImage. Now we need to add the selecting part. We will begin by writing a function that will return the window controller responsible for selecting.

class ScreenshotManager {
...
static func returnWindowController() -> NSWindowController {

    let window = NSWindow(contentRect: .zero, styleMask: [.fullSizeContentView], backing: .buffered, defer: false)
    window.isOpaque = false
    window.backgroundColor = .clear
    window.titleVisibility = .hidden
    window.titlebarAppearsTransparent = true
    window.hasShadow = false

    return NSWindowController(window: window)

  }
}

This function configures the selection window. It makes it transparent using isOpaque and backgroundColor. It also removes all decorations (titlebar and shadow). Now let’s add the main function responsible for starting this process.

class ScreenshotManager {
...
    @MainActor
    static func start(completionHandler: @escaping (Result<NSImage, Error>) -> Void) -> Error? {
        if self.isRunning {
            return SMError.alreadyInUse
        }

        guard let screen = NSScreen.main else { return SMError.noAccessToScreen }

        if !CGPreflightScreenCaptureAccess() {
           return SMError.noPermission
        }

        Self.completionHandler = completionHandler

        windowController = returnWindowController()
        windowController?.contentViewController = SelectionWindowViewController()
        windowController?.window?.setFrame(NSRect(x: 0, y: 0, width: screen.frame.size.width, height: screen.frame.size.height), display: false)
        windowController!.showWindow(nil)
        windowController?.window?.makeKeyAndOrderFront(nil)

        return nil
    }
}

This function accepts the completionHandler that will run once the selection ends and it also returns an error when there is selection already taking place, NSScreen.main is nil and if the app doesn’t have a screen capture permission (CGPreflightScreenCaptureAccess()). The function then configures and shows a window controller from the returnWindowController() function. The window will appear on the current space and overlay all windows. Now it’s time for the selection window.

Selection window

Let’s begin by defining the SelectionWindowViewController class inheriting from NSViewController, variables and it’s viewDidLoad() function.

class SelectionWindowViewController: NSViewController {
  var selectionView: NSBox? = nil
  var centerPoint: CGPoint = .zero
  var overlay: NSView! = nil

  override func viewDidLoad() {
    super.viewDidLoad()

    overlay = NSView(frame: view.bounds)
    overlay.wantsLayer = true
    overlay.layer?.backgroundColor = NSColor.black.withAlphaComponent(0.5).cgColor

    view = overlay
}

The view controller defines three variables. selectionView which will contain the view that selects part of the screen, overlay view which darkens the screen and the centerPoint containing position of the mouse click. viewDidLoad() configures the overlay by making it transparent with a dark tint controlled by 0.5 parameter.

Note: Builtin screenshot app changes the cursor into crosshair. I tried adding it, but it looks like it loses focus and the cursor changes back. If you want to try to implement it, you will probably need to use a function like self.view.addCursorRect(self.view.bounds, cursor: .crosshair) or NSCursor.crosshair.push().

To achieve the effect of transparent cutout within dark overlay we will need to use CALayer s which is implemented by setMask() function.

class SelectionWindowViewController: NSViewController {
...
    func setMask() {
        guard let overlayLayer = view.layer else { return }

        let maskLayer = CALayer()
        maskLayer.frame = overlayLayer.bounds

        let path = CGMutablePath()
        path.addRect(overlayLayer.bounds)
        path.addRect(selectionView!.frame)

        let cutoutLayer = CAShapeLayer()
        cutoutLayer.frame = overlayLayer.bounds
        cutoutLayer.fillRule = .evenOdd
        cutoutLayer.fillColor = NSColor.black.cgColor
        cutoutLayer.path = path

        maskLayer.addSublayer(cutoutLayer)
        overlayLayer.mask = maskLayer
    }
}

This function will be called after every movement. It cuts out a part of the overlay. The most important part of this snippet is the .evenOdd fill rule. It is responsible for giving us the cut out effect. How des it work? Claude describes it like this:

1. Imagine drawing a line from any point in the plane to infinity.
2. Count the number of times this line crosses the path of your shape.
3. If the number of crossings is odd, the point is inside the shape and gets filled. If the number of crossings is even, the point is outside the shape and doesn't get filled.

In the context of this function it works like this:

The path includes two rectangles: one for the entire view bounds, and another for the selection view.
For areas outside both rectangles, the line crosses 0 times (even) - not filled.
For areas inside the outer rectangle but outside the inner rectangle, the line crosses 1 time (odd) - filled.
For areas inside both rectangles, the line crosses 2 times (even) - not filled.

Now let’s implement selecting. First we begin with the function detecting first click:

class SelectionWindowViewController: NSViewController {
...
  override func mouseDown(with event: NSEvent) {
    super.mouseDown(with: event)

    selectionView = NSBox()

    selectionView?.boxType = .custom
    selectionView?.cornerRadius = 0
    selectionView?.fillColor = .lightGray
    selectionView?.title = ""

    self.view.addSubview(selectionView!)

    selectionView?.frame.origin = .init(x: event.locationInWindow.x, y: event.locationInWindow.y)
    centerPoint = selectionView!.frame.origin

    setMask()
  }
}

This function creates the selection view. setMask() uses it create the cutout. It’s configuration should be self-explanatory. We also set its origin to the position of the mouse, which is stored in event.locationInWindow, and run setMask() to create the cutout. Now it’s time to handle mouse movement.

class SelectionWindowViewController: NSViewController {
...
  override func mouseDragged(with event: NSEvent) {
    super.mouseDragged(with: event)

    guard let selectionView else { return }

    let width = abs(centerPoint.x - event.locationInWindow.x)
    let height = abs(centerPoint.y - event.locationInWindow.y)

    selectionView.frame.size = .init(width: width, height: height)

    if event.locationInWindow.x < centerPoint.x && event.locationInWindow.y < centerPoint.y {
      selectionView.frame.origin = .init(x: event.locationInWindow.x, y: event.locationInWindow.y)
    } else if event.locationInWindow.x < centerPoint.x {
      selectionView.frame.origin = .init(x: event.locationInWindow.x, y: centerPoint.y)
    } else if event.locationInWindow.y < centerPoint.y {
      selectionView.frame.origin = .init(x: centerPoint.x, y: event.locationInWindow.y)
        } else {
            selectionView.frame.origin = .init(x: centerPoint.x, y: centerPoint.y)
        }

        setMask()
    }
}

Here we need a little bit more work. We first check if the selection view exists, then we calculate and assign the new width and height by taking absolute values of appropriate subtractions. Now we have 4 cases for each possible change of cursor’s position relative to the center point (first mouse click). This is because the origin of the selection view has to always be in the bottom-left corner, so if we move cursor down or left relative to the center point we will need to update selection view’s origin coordinates.

Cursor is in the bottom-left part - origin point equal to the cursor position.
Cursor is in the top-left part - origin point’s x equal to cursor’s x and origin point’s y equal to center point’s y.
Cursor is in the bottom-right part - origin point’s x equal to center point’s x and origin point’s y equal to cursor’s y.
Cursor is in the top-right part - origin point equal to the center point.

Now it’s time for the final part - the user finished selecting (mouse up).

class SelectionWindowViewController: NSViewController {
...
  override func mouseUp(with event: NSEvent) {
    super.mouseDown(with: event)

    guard let selectionView else { return }

    self.window?.close()

    var frame = selectionView.frame
    frame.origin.y = NSScreen.main!.frame.maxY - frame.size.height - frame.origin.y

    do {
      let image = try ScreenshotManager.take(frame: frame)
      NSSound.beep()
      ScreenshotManager.completionHandler(.success(image))
      ScreenshotManager.completionHandler = { \_ in }
    } catch {
      ScreenshotManager.completionHandler(.failure(error))
      ScreenshotManager.completionHandler = { \_ in }
    }
  }

  var window: NSWindow? {
    for window in NSApp.windows {
      if window.contentViewController == self {
        return window
      }
    }

    return nil
  }
}

First we close the window. Now we need to calculate the frame of the selection. Unfortunately, origin’s y in the window (same size as the screen) doesn’t correspond to the screen’s actual position. That’s because screen’s coordinates are flipped horizontally - y = 0 is on the screen’s top-left corner while in a window it’s the bottom-left corner. I simply calculate it by subtracting selection’s height and origin from screen’s height. There are builtin functions to convert between these two coordinate systems but I tried and none of them worked. If you can make them work, then using them would probably be a better practice, but this calculation should be enough. Now we call the ScreenManager.take() function which takes the image of the part of the screen described by the converted selection’s frame. For good measure we make a beep. Then we call the currently set completion handler with the image and reset it. In case of an error, we call the completion handler with the error and reset it. I’m also adding a window variable so that we can access the window from it. It’s not the most efficient way, but it’s enough for this use case.

Well, that’s it. That will allow you to take a screenshot of part of the screen.

import Cocoa

class ScreenshotManager {
  private static var windowController: NSWindowController? = nil
  private static var isRunning = false
  static var completionHandler: (Result<NSImage, Error>) -> Void = { \_ in }

  enum SMError: Error, LocalizedError {
    case failedToTakeScreenshot
    case noSelection
    case alreadyInUse
    case noPermission
    case noAccessToScreen
  }

  @MainActor
  static func take(frame: NSRect) throws -> NSImage {
    isRunning = false

    let cgRect = CGRect(
      x: frame.origin.x, y: frame.origin.y, width: frame.width, height: frame.height)
    guard let screenshot = CGWindowListCreateImage(cgRect, .optionOnScreenOnly, .zero, []) else {
      throw SMError.failedToTakeScreenshot
    }

    return NSImage(
      cgImage: screenshot, size: .init(width: screenshot.width, height: screenshot.height))
  }

  static func returnWindowController() -> NSWindowController {
    let window = NSWindow(
      contentRect: .zero, styleMask: [.fullSizeContentView], backing: .buffered, defer: false)

    window.isOpaque = false
    window.backgroundColor = .clear
    window.titleVisibility = .hidden
    window.titlebarAppearsTransparent = true
    window.hasShadow = false

    return NSWindowController(window: window)
  }

  @MainActor
  static func start(completionHandler: @escaping (Result<NSImage, Error>) -> Void) -> Error? {
    guard let screen = NSScreen.main else { return SMError.noAccessToScreen }

    if !CGPreflightScreenCaptureAccess() {
      return SMError.noPermission
    }

    if self.isRunning {
      return SMError.alreadyInUse
    }

    Self.completionHandler = completionHandler

    windowController = returnWindowController()
    windowController?.contentViewController = SelectionWindowViewController()
    windowController?.window?.setFrame(
      NSRect(x: 0, y: 0, width: screen.frame.size.width, height: screen.frame.size.height),
      display: false)
    windowController!.showWindow(nil)
    windowController?.window?.makeKeyAndOrderFront(nil)

    return nil
  }
}

class SelectionWindowViewController: NSViewController {
  var selectionView: NSBox? = nil
  var centerPoint: CGPoint = .zero
  var overlay: NSView! = nil

  override func viewDidLoad() {
    super.viewDidLoad()

    overlay = NSView(frame: view.bounds)
    overlay.wantsLayer = true
    overlay.layer?.backgroundColor = NSColor.black.withAlphaComponent(0.5).cgColor
    view = overlay

    self.view.addCursorRect(self.view.bounds, cursor: .crosshair)
    NSCursor.crosshair.push()
  }

  override func mouseDown(with event: NSEvent) {
    super.mouseDown(with: event)

    selectionView = NSBox()

    selectionView?.boxType = .custom
    selectionView?.cornerRadius = 0
    selectionView?.fillColor = .lightGray
    selectionView?.title = ""

    self.view.addSubview(selectionView!)

    selectionView?.frame.origin = .init(x: event.locationInWindow.x, y: event.locationInWindow.y)
    centerPoint = selectionView!.frame.origin

    setMask()
  }

  override func mouseDragged(with event: NSEvent) {
    super.mouseDragged(with: event)

    guard let selectionView else { return }

    let width = abs(centerPoint.x - event.locationInWindow.x)
    let height = abs(centerPoint.y - event.locationInWindow.y)

    selectionView.frame.size = .init(width: width, height: height)

    if event.locationInWindow.x < centerPoint.x && event.locationInWindow.y < centerPoint.y {
      selectionView.frame.origin = .init(x: event.locationInWindow.x, y: event.locationInWindow.y)
    } else if event.locationInWindow.x < centerPoint.x {
      selectionView.frame.origin = .init(x: event.locationInWindow.x, y: centerPoint.y)
    } else if event.locationInWindow.y < centerPoint.y {
      selectionView.frame.origin = .init(x: centerPoint.x, y: event.locationInWindow.y)
    } else {
      selectionView.frame.origin = .init(x: centerPoint.x, y: centerPoint.y)
    }

    setMask()
  }

  override func mouseUp(with event: NSEvent) {
    super.mouseDown(with: event)

    guard let selectionView else { return }

    self.window?.close()

    var frame = selectionView.frame
    frame.origin.y = NSScreen.main!.frame.maxY - frame.size.height - frame.origin.y

    do {
      let image = try ScreenshotManager.take(frame: frame)
      NSSound.beep()
      ScreenshotManager.completionHandler(.success(image))
      ScreenshotManager.completionHandler = { \_ in }
    } catch {
      ScreenshotManager.completionHandler(.failure(error))
      ScreenshotManager.completionHandler = { \_ in }
    }
  }

  func setMask() {
    guard let overlayLayer = view.layer else { return }

    let maskLayer = CALayer()
    maskLayer.frame = overlayLayer.bounds

    let path = CGMutablePath()
    path.addRect(overlayLayer.bounds)
    path.addRect(selectionView!.frame)

    let cutoutLayer = CAShapeLayer()
    cutoutLayer.frame = overlayLayer.bounds
    cutoutLayer.fillRule = .evenOdd
    cutoutLayer.fillColor = NSColor.black.cgColor
    cutoutLayer.path = path

    maskLayer.addSublayer(cutoutLayer)
    overlayLayer.mask = maskLayer
  }
}

extension NSViewController {
  var window: NSWindow? {
    for window in NSApp.windows {
      if window.contentViewController == self {
        return window
      }
    }

    return nil
  }
}