When source code moves: Halide, Apple and lessons for developers

What happened (high level)

A legal dispute between Halide’s founders has put a spotlight on a practical threat every software startup faces: what happens to your intellectual property when a co‑founder leaves and joins a big tech company? Co‑founder Ben Sandofsky has filed suit against former partner Sebastiaan de With, alleging de With was fired for financial misconduct and later brought Halide source code to Apple. Those are the claims in the filing; the case is now in the courts and could take months to resolve.

Halide is a well‑known third‑party iOS camera app built around computational photography and a developer reputation for clean design and strong imaging features. The dispute raises questions about code custody, trade secrets, and how both startups and large companies handle acquisitions or hires from small teams.

Why this matters beyond the headlines

At first glance the story is about two founders and a legal fight. For founders, engineers, and product leaders the practical lessons are immediate:

• Source code is more than a repository: it encodes product ideas, algorithms, business logic and often the path to future features. When a co‑founder leaves, control of that asset can determine product continuity.
• Hiring engineers from competitors — or taking a developer from a startup — creates legal and operational risk for the hiring company if any proprietary materials travel with the hire.
• Startups often assume trust among founders; disputes reveal the need for explicit policies and technical controls.

The legal tools that typically come into play

Cases like this usually hinge on a mix of contract and statutory law:

• Intellectual Property Assignment: Most startups have contributors sign an IP assignment or employ agreements that assign rights in code and inventions to the company. Missing or ambiguous assignments make litigation harder to resolve cleanly.
• Trade Secret Law: If a piece of code or an algorithm is kept confidential and its disclosure harms the company, trade secret claims can apply. Courts look at whether reasonable steps were taken to protect secrecy.
• Copyright: Source code is automatic copyrightable material. Unauthorized copying or distribution can be addressed through copyright claims.
• Contract & Fiduciary Claims: Alleged financial misconduct, wrongful termination, or breach of fiduciary duties can compound IP claims.

The plaintiff typically seeks injunctive relief (to prevent the other party from using the code) and damages.

Real‑world scenarios this could create

Here are three plausible situations illustrating how this kind of dispute plays out operationally:

1) Fragmented updates: If the departing founder has the only working knowledge of a critical module and takes a copy, the remaining team may struggle to ship updates or fix security bugs.

2) Feature leakage: Suppose proprietary image‑processing code — say a unique demosaicing or noise‑reduction algorithm — appears in a competitor product. That can damage the startup’s market advantage and spur litigation.

3) Employer exposure: A large employer (here, Apple) that hires a developer who brings code could be pulled into the dispute. Even if the employer had no knowledge, the company may face discovery requests and reputational issues.

Practical steps startups should take now

This dispute is a reminder to build operational and legal hygiene into the product lifecycle. Practical measures include:

• Make IP assignment explicit and early: Ensure all founders, contractors, and employees sign clear IP assignment agreements and invention disclosure policies.
• Enforce least privilege: Use role‑based access controls so only necessary engineers can read or push sensitive repositories.
• Centralize secrets and algorithms: Keep proprietary or production‑critical algorithms in private, audited registries and avoid distributing full source checkouts unnecessarily.
• Maintain thorough audit trails: Log access to repositories and critical builds. In a dispute, logs are often decisive evidence.
• Offboarding playbooks: When someone leaves, revoke all access immediately, collect company devices, and run an audit to confirm no data left behind.
• Legal contingency planning: Keep a small standard‑form cease‑and‑desist and litigation escalation plan with counsel familiar with trade secret and IP disputes.

These measures are low friction for small teams and high payoff if a dispute happens.

How companies that hire startup talent should respond

Big firms routinely hire employees from startups. To reduce exposure:

• Require new hire attestations: Ask new employees to identify any repositories or materials they contributed to and produce attestations that they’re not bringing proprietary code.
• Implement a clean room policy: If code needs to be reimplemented, do so from scratch with engineers who did not have access to the original codebase.
• Conduct IP ingestion reviews: Larger flows of code from acquisitions or hires should go through legal and engineering review before being merged into product codebases.

Apple and other large platforms have legal teams and policies, but public disputes underscore that risk remains if processes fail or aren’t followed.

Tradeoffs and limitations of stricter controls

Tightening access and adding legal overhead can slow early‑stage engineering. Small teams prize velocity, and heavy‑handed controls can hurt culture.

A balanced approach is pragmatic: start with basic IP assignments and RBAC now, and incrementally add formal processes only as the team and product complexity grow.

Broader implications for startups and the industry

1) Stronger IP hygiene will become a competitive discipline. As more startups are founded by small teams and then see talent move to larger companies, investors and acquirers will expect clear records of code ownership.

2) Hiring practices will change. Employers will be more careful taking engineers from small teams without clear documentation and may prefer clean‑reimplementation routes.

3) Legal clarity matters for product roadmaps. Startups that cannot prove ownership of core components risk losing the right to monetize them — a structural threat to long‑term value.

What to watch next

This lawsuit will primarily resolve factual questions about what code left the company and whether contractual or statutory protections were violated. Beyond the courtroom outcome, the more valuable lesson is operational: protecting your product hinges on both legal agreements and everyday engineering discipline.

If you run or work at a startup, ask yourself: when was the last time your team audited who has access to your code and whether your IP assignment paperwork is complete? If you can’t answer immediately, prioritize that audit this week.