标签：#art

SpaceX will likely attempt to catch Starship back at the launch pad on its next flight.

If you need to juice up your phone in a hurry, there are more effective tactics than turning on airplane mode.

Cloud storage isn't your only option.

Here are a few things to know if you're leaving Android for iPhone.

Subscription Goldmine: SaaS Models and Startup Cash Flow Here's the brutal truth: nothing brings a tech solopreneur closer to existential dread than staring down a dried-up cash runway in the office at midnight. This concern is universal for founders, whether you're nestled in a cozy Davao home office or grinding away in a bustling city. The rise of subscription-based Software as a Service (SaaS) models is shifting this narrative, offering both solutions and new challenges. The stakes are high, but so are the potential rewards. The Core Problem & Why This Matters Startups live and die by their cash flow. Managing liquidity is crucial for keeping the lights on and securing future growth. Traditional software sales were typically characterized by large, one-time purchases. This model, while sometimes lucrative, posed significant challenges for startups that needed a steady influx of cash. The subscription model flips this on its head by transforming how revenue is recognized, providing a more predictable income stream. The consistent monthly inflows from subscriptions give startups the cushion they need to weather the ups and downs of growth periods. But here's the catch: converting users into paying subscribers isn’t a cakewalk. It requires upfront investments in product development, marketing, and customer support. Yet, this model becomes a vital lifeline, especially when venture capital isn't an option. Subscription models necessitate long-term engagement strategies, but they offer a recurring revenue stream that can stabilize an otherwise volatile cash flow. The Systems Engineering Approach Developing a subscription-based SaaS model requires a meticulous systems approach. The first step involves designing a seamless user experience . Every touchpoint must be optimized to retain users and convert trial customers into paid subscribers. From initial sign-up to daily usage, every feature should scream value. Next, focus on robust backend systems. These systems are the

Museums are embracing data-driven curation and a shifting technology landscape.

In 2024, everyone and their manager launched an AI wrapper. A thin layer over GPT-4, a nice UI, a subscription fee, and boom: you were an AI company. Product Hunt had hundreds of these launches. Investors poured money into them. And by 2026, most of them are dead. Not all of them though. A handful survived and crossed real revenue milestones. Their stories reveal something important about where the AI market is actually going. The wrappers died but the value moved somewhere real. What Actually Killed the Wrappers The math never worked. An AI wrapper is a startup whose core product is a prompt sent to someone else's model. You pay OpenAI (or Anthropic or Google) for tokens. You charge your users a markup. And you hope the difference covers your hosting, your team, and your coffee. Three things broke that math. First, the model providers kept getting cheaper. OpenAI cut prices multiple times through 2024 and 2025. As TechCrunch reported , each price drop squeezed the wrapper margin another notch. If you were marking up tokens 3x and the base price dropped 50%, your margin went from 200% to 50% overnight. Second, the big models got good enough at general tasks that users stopped needing the specialized UI. Why pay $20/month for a writing assistant that wraps ChatGPT when you can just use ChatGPT directly? The OpenAI GPT Store made this worse: custom GPTs replaced a huge chunk of wrapper functionality for free. Third, users wised up. The initial AI hype in 2023 convinced people to pay for anything with "AI" in the name. By 2025, that was over. G2's research showed that enterprises stopped buying standalone AI tools and started demanding AI features built into their existing software stacks. The result was predictable. Hundreds of wrapper startups shut down, got acquired for pennies, or pivoted to something completely different. What Actually Works Now The survivors fall into three categories. Each one solves the problem the wrappers ignored: building defensible value on

Everyone says the same thing: Flutter is for apps, not games. So I decided to find out where that's actually true — by building a 3D endless runner in Flutter. From scratch. No Unity, no Unreal, no game engine at all. Just Dart and Flutter's own rendering stack. It runs in your browser right now: ▶️ Play it live (desktop, keyboard controls — A / D to switch lanes, Space to jump). Here's how it works, and what building it taught me about how far Flutter can actually go. The stack: Flutter GPU + flutter_scene The whole thing sits on two pieces most Flutter developers have never touched: Flutter GPU — a low-level rendering API that talks almost directly to the GPU through Impeller (the engine that replaced Skia). This is what makes real-time 3D possible at all. flutter_scene — a higher-level 3D scene API on top of Flutter GPU. It gives you the building blocks a game needs: a scene graph of nodes , a perspective camera , meshes, and glTF model loading. You build a tree of nodes, point a camera at it, and render it every frame inside a normal Flutter widget. That last part still surprises me — the 3D world is just a CustomPaint -style surface living inside an otherwise ordinary Flutter app. Faking an infinite world with a handful of objects An "endless" runner obviously can't build an endless world — you'd run out of memory in seconds. The trick is object pooling : you keep a small pool of track segments and obstacles, and as they scroll past the camera behind the player, you recycle them back to the front with new positions. The player never actually moves forward. The world moves toward the player , and a fixed number of segments cycle forever. Same idea for obstacles and coins. It means the game runs at a constant, tiny memory footprint — which is exactly what keeps it smooth on weaker devices. The parts that were genuinely hard Collision that feels fair. Detecting a collision is easy. Making it feel right is not. Too strict and the player rages at hits that "clearly

The neolab is betting that automating routine computer tasks will soon outpace coding as AI's biggest use case.

Money has evolved into far more than the cash in your wallet or your bank account. And at TechCrunch Disrupt 2026, we’re devoting an entire stage to that progression.

"We can quash the subpoenas, or you could withdraw the subpoenas,” judge told US.

On this episode of Uncanny Valley, we dive into accusations that China’s Moonshot AI stole from Anthropic, and how the US Army needs to cut back on AI use.

AI tools have democratized the opportunity to build, shortening the timelines of success and enabling more young people to start successful companies without stepping foot inside a Big Tech company.

The first time I audited seriously, I opened the biggest contract in the repo and started reading line one. Two hours later I had a headache and zero findings. I had memorized how the code worked without ever asking what it was supposed to guarantee. That is backwards, and it took me a while to unlearn it. Now I do not read Solidity first. I read the scope, and before I look at a single function body I write down what must always be true. Bugs are violations of those truths. If you do not know the truths, you are just admiring the code. Step one: write the invariants before you read An invariant is a property the protocol claims will always hold, no matter who calls what in what order. For a contest, I start with money and control, because that is where severity lives. Two questions cover most of it: Who can move funds, and under what conditions? What must always hold about the accounting? For a lending-pool-shaped protocol my starting invariant list looks like this, written in plain language before I care how any of it is implemented: The sum of all user deposits minus all borrows equals the pool's available liquidity plus outstanding debt. Accounting must reconcile. A user can only withdraw up to their own balance, never more, never someone else's. A position can only be liquidated when it is actually under the health threshold. Interest accrues monotonically, it never goes backwards in a way that lets someone repay less than they owe. Only the borrower, or a liquidator on an unhealthy position, can reduce a debt. Nobody except governance can change interest rate parameters or the oracle. Notice none of that mentions a function name. These are the promises. Now my job for the rest of the contest is simple to state: find an ordering of calls that breaks one of these. Step two: map the external entry points Funds do not teleport. Something has to be called from outside for state to change. So I list every externally reachable function, because the attack surface is

Following its Unpacked launch event for the Galaxy Z Fold 8 series, Samsung briefly opened a theme pub in the middle of London.

US robotics researchers flew to Venezuela with snakebots after getting a call.

“I think it should stand for artificial idiot,” one 9-year-old says. Here’s why kids of all ages are calling AI “disgusting” and “creepy.”

The article discusses an experiment where a code assistant had to design an agentic system using LangChain4j documentation. The assistant created a coding framework capable of writing, testing, and debugging code autonomously. Results showed that two architectural patterns—supervisor and workflow—offered different trade-offs between flexibility and execution speed during debugging tasks. By Kevin Dubois, Mario Fusco

TechCrunch Startup Battlefield is coming to Australia — and we're partnering with Stripe to find the country's most exciting early-stage startups.

You built something. Tests pass. You're days from mainnet. Before you either skip security entirely (please don't) or spend weeks lining up a full audit, here's a self-check you can run in 20 minutes that catches the mistakes I see most often in first-time deployments. I run security reviews for small and new protocols, and the same handful of issues come up again and again. None of these need a tool — just your eyes and this list. 1. Who can call what? Open every external / public function that moves funds, mints, pauses, or upgrades. For each, ask: should a random address be able to call this? If not — is there an onlyOwner / onlyRole / require(msg.sender == ...) guarding it, in the function itself or in every internal function it calls? The classic bug isn't a missing modifier. It's a function that looks unguarded but delegates to a guarded internal one (fine), or one that looks guarded but the guard is in a branch a caller can skip (not fine). Trace the call, don't trust the signature. 2. The first-depositor trap (if you have a vault) If you mint shares from deposits (ERC-4626 or anything share-based), the first depositor can sometimes donate assets directly to the contract to inflate the share price, so the second depositor rounds down to zero shares and loses funds. Fix: virtual shares, a dead-shares mint at deploy, or a minimum-liquidity lock. OpenZeppelin's ERC-4626 handles this out of the box — a hand-rolled vault usually doesn't. 3. Reentrancy — but only the real kind Not every external call is reentrancy. It's a bug when an attacker-controlled call can re-enter and corrupt shared storage before you've updated it. Quick checks: Do you update state before the external transfer (checks-effects-interactions)? Is there a nonReentrant on functions that move value? Is the call target a trusted, immutable contract, or an arbitrary address the attacker supplies? A call to a protocol-owned contract, or a memory /local variable written after the call, is usually not