Today
Front-end, in one read.
The latest from the sources worth following, newest first.
DEV CommunityThe Giantsread at source
Implementing Structured Output Retries Without Infinite Agent Loops
Structured outputs are one of the most useful capabilities in modern LLM applications. Instead of returning unstructured text, a model can generate JSON objects that applications use for classification, data extraction, tool execution, and workflow decisions. But structured output does not automatically mean reliable output. A model may return valid JSON with missing fields, unsupported values, incorrect data types, or arguments that violate business rules. The usual solution is to retry the model with an explanation of what went wrong. That approach works until the retry logic becomes another source of failure. An agent may repeatedly generate invalid responses, retry with nearly identical instructions, and continue consuming tokens without making progress. Reliable structured output handling requires more than schema validation. It needs bounded retries, explicit failure states, and a clear distinction between recoverable formatting errors and application-level failures. In this guide, we'll build a lightweight structured output retry mechanism using Python and Pydantic. We'll also add regression tests, retry budgets, failure classification, and safeguards against infinite agent loops. 1. Why Structured Output Retries Become Dangerous Consider an AI agent that extracts invoice information from documents. The application expects: { "invoice_id" : "INV-1042" , "amount" : 1250.50 , "currency" : "USD" , "approved" : false } The response must satisfy several requirements: invoice_id must be a non-empty string. amount must be greater than zero. currency must use a supported currency code. approved must be a Boolean. Now imagine the model returns: { "invoice_id" : "INV-1042" , "amount" : "unknown" , "currency" : "USD" , "approved" : "maybe" } The JSON syntax is valid, but the data violates the expected schema. A developer might implement: while True : response = call_model ( ) try : return validate ( response ) except Exception : continue This code has several problems. First, the loop has no termination condition. Second, it retries on every exception, including programming errors that another model call cannot fix. Third, it provides no feedback explaining why validation failed. Fourth, it may repeatedly generate the same invalid response. In a production agent, this can increase cost, latency, and infrastructure usage while preventing the workflow from completing. The solution is to make retries an explicit part of the application's control flow. 2. Separate JSON Parsing From Schema Validation Structured output failures occur at different levels. JSON syntax errors The response cannot be parsed as JSON. Example: { "invoice_id" : "INV-1042" , "amount" : 1250.50 , } The trailing comma makes this invalid JSON. Schema validation errors The JSON parses successfully but does not match the expected structure. Example: { "invoice_id" : "INV-1042" , "amount" : "unknown" } Required fields are missing or contain invalid values. Business-rule violations The output matches the schema but violates an application-specific requirement. For example, an invoice may have a valid positive amount but exceed the amount the user is authorized to approve. Tool execution failures The structured output may be correct, but the external API rejects the operation or becomes unavailable. These failures should not share the same retry policy. A formatting problem may justify asking the model to regenerate its response. An authorization failure should generally stop execution. A network timeout may require an infrastructure-level retry rather than another model generation. The first design rule is to classify failures before deciding whether another LLM call is appropriate. 3. Project Structure We'll build a small example with the following files: structured-output-retries/ | |-- models.py |-- retry_handler.py |-- test_retry_handler.py |-- requirements.txt | -- .github/ -- workflows/ -- tests.yml` The implementation uses Python 3.11 or later. Install the dependencies: shell python -m pip install "pydantic>=2, Create requirements.txt: pydantic>=2, pytest>=8, The retry handler will use a callable model interface rather than depending on a specific LLM provider. That makes the implementation easier to test. 4. Define a Strict Structured Output Schema Create models.py: `python from typing import Literal from pydantic import ( BaseModel, ConfigDict, Field ) class InvoiceExtraction(BaseModel): model_config = ConfigDict( extra="forbid", strict=True ) invoice_id: str = Field( min_length=1 ) amount: float = Field( gt=0 ) currency: Literal[ "USD", "EUR", "GBP" ] approved: bool ` This schema enforces several constraints. The extra="forbid" configuration rejects unexpected fields. Strict validation prevents implicit type coercion where supported by the field type. The amount must be positive. The currency must match one of the allowed values. The approved field must be a Boolean. Why strict validation matters Without strict validation, some frameworks may automatically convert values. For example, a string containing a number might be accepted as a numeric field. That behavior can be convenient for ordinary form processing. For AI-generated outputs, however, it may hide inconsistent model behavior. Strict validation makes failures more visible and easier to evaluate. Schema validation is not authorization The approved field is included to demonstrate Boolean validation. It must not be treated as proof that a real invoice has been authorized. A production payment or approval system should obtain authorization from trusted application state and enforce it independently of the model-generated output. 5. Define Explicit Retry Limits The retry mechanism needs a clear execution budget. We'll use three controls: Maximum model attempts. Maximum repeated identical invalid responses. A wall-clock deadline checked between attempts. These controls address different failure patterns. The attempt limit prevents unlimited model calls. The repeated-response limit detects situations where the model produces the same invalid result without improvement. The deadline prevents the retry handler from continuing after the allotted execution window. A deadline check between calls cannot interrupt a model request that is already running. The model client must enforce its own request timeout. Define retry-specific exceptions Create retry_handler.py: `python import json import time from collections.abc import Callable from dataclasses import dataclass from pydantic import ValidationError from models import InvoiceExtraction class StructuredOutputError(Exception): pass class RetryBudgetExceeded( StructuredOutputError ): pass class RepeatedInvalidOutput( StructuredOutputError ): pass class RetryDeadlineExceeded( StructuredOutputError ): pass @dataclass(frozen=True) class RetryPolicy: max_attempts: int = 3 max_identical_failures: int = 2 timeout_seconds: float = 30.0 def __post_init__(self): if self.max_attempts ` The policy is immutable. This helps prevent retry limits from being modified accidentally during execution. 6. Implement Structured Output Validation Next, create a function that parses and validates the model response. Add this to retry_handler.py: `python def parse_structured_output( raw_response: str ) -> InvoiceExtraction: try: payload = json.loads(raw_response) except json.JSONDecodeError as exc: raise StructuredOutputError( f"Invalid JSON: {exc.msg}" ) from exc try: return InvoiceExtraction.model_validate( payload ) except ValidationError as exc: errors = exc.errors( include_url=False, include_input=False ) raise StructuredOutputError( f"Schema validation failed: {errors}" ) from exc ` This function handles two specific failure categories. If JSON parsing fails, it raises a structured output error. If Pydantic validation fails, it raises a structured output error containing validation details. Other unexpected exceptions are not converted into retryable errors. That distinction is important. A programming error should not trigger repeated model calls. 7. Implement the Bounded Retry Handler Now we can build the retry loop. The handler accepts a callable that generates a model response. The callable receives optional validation feedback from the previous attempt. Add this to retry_handler.py: `python def generate_with_retries( model_call: Callable[ [str | None], str ], policy: RetryPolicy ) -> InvoiceExtraction: started_at = time.monotonic() previous_invalid_output = None identical_failures = 0 validation_feedback = None for attempt in range( 1, policy.max_attempts + 1 ): elapsed = ( time.monotonic() - started_at ) if elapsed >= policy.timeout_seconds: raise RetryDeadlineExceeded( "Retry deadline exceeded" ) raw_response = model_call( validation_feedback ) try: return parse_structured_output( raw_response ) except StructuredOutputError as exc: if raw_response == previous_invalid_output: identical_failures += 1 else: identical_failures = 1 previous_invalid_output = raw_response if ( identical_failures >= policy.max_identical_failures ): raise RepeatedInvalidOutput( "Model repeatedly returned " "the same invalid output" ) from exc validation_feedback = str(exc) raise RetryBudgetExceeded( "Maximum structured output " "attempts exceeded" ) ` This implementation guarantees that the handler initiates no more than the configured number of model calls. It also detects repeated identical invalid responses. The retry loop terminates when: The model produces valid structured output. The attempt budget is exhausted. The repeated-invalid-output limit is reached. The deadline is exceeded before an attempt. Why the loop is safer There is no while True. The number of attempts is explicit. Only structured output validation errors are retried. Unexpected model-client exceptions propagate to the caller. The handler does not execute any external business action. It only produces validated data. That separation reduces the risk of repeating side effects during output repair. 8. Provide Validation Feedback to the Model Retries are more useful when the model knows what failed. Instead of repeating the original prompt unchanged, provide concise validation feedback. For example: `plaintext Your previous response failed validation. Errors: amount must be a positive number approved must be a Boolean currency must be USD, EUR, or GBP Return only a valid JSON object matching the schema. ` The retry handler already passes validation feedback to the model callable. A provider-specific adapter can use that feedback to construct the next request. Conceptually: `python def model_call( validation_feedback: str | None ) -> str: messages = [ { "role": "system", "content": ( "Extract invoice information " "as valid JSON." ) } ] if validation_feedback: messages.append({ "role": "user", "content": ( "The previous output failed " "validation:\n" + validation_feedback ) }) return call_llm_provider(messages) ` This is integration pseudocode. The call_llm_provider function must be implemented using the selected model provider's SDK. Avoid feeding unlimited error history back to the model Some retry implementations append every failed response and validation error to the conversation. Over time, the prompt becomes larger and more confusing. A better approach is to keep only the information needed for the next repair attempt. For example: The original task. The required schema. The latest validation errors. Relevant source data. This keeps the repair process focused. Validation feedback should also be sanitized and bounded before being included in a prompt. 9. Test Successful Recovery After an Invalid Response We can test the retry handler without calling a real LLM. Create test_retry_handler.py: `python from retry_handler import ( RetryPolicy, generate_with_retries, RetryBudgetExceeded, RepeatedInvalidOutput ) def test_recovers_after_invalid_json(): responses = iter([ '{"invoice_id": "INV-1",', ( '{"invoice_id": "INV-1", ' '"amount": 100.0, ' '"currency": "USD", ' '"approved": false}' ) ]) feedback_received = [] def fake_model(feedback): feedback_received.append( feedback ) return next(responses) result = generate_with_retries( fake_model, RetryPolicy( max_attempts=3, max_identical_failures=2 ) ) assert result.invoice_id == "INV-1" assert result.amount == 100.0 assert result.approved is False assert feedback_received[0] is None assert feedback_received[1] is not None ` The first response contains invalid JSON. The second response is valid. The test verifies that the retry handler recovers successfully and provides feedback after the first failure. 10. Test Retry Budget Exhaustion A reliable retry mechanism must stop when the model continues producing invalid output. Add this test: `python def test_retry_budget_exceeded(): responses = iter([ '{"amount": "invalid"}', '{"currency": "unknown"}', '{"approved": "maybe"}' ]) calls = 0 def fake_model(feedback): nonlocal calls calls += 1 return next(responses) try: generate_with_retries( fake_model, RetryPolicy( max_attempts=3, max_identical_failures=3 ) ) except RetryBudgetExceeded: pass else: raise AssertionError( "Expected retry budget failure" ) assert calls == 3 ` The model produces three different invalid responses. The handler stops after the configured maximum of three attempts. This prevents an infinite loop even when the model never returns valid data. 11. Detect Repeated Invalid Responses Some models repeatedly produce the same malformed structure. For example: json { "invoice_id": "INV-1042", "amount": "unknown" } If the model returns this exact response multiple times, another retry may not be useful. Add the following test: `python def test_repeated_invalid_output(): calls = 0 def fake_model(feedback): nonlocal calls calls += 1 return '{"amount": "unknown"}' try: generate_with_retries( fake_model, RetryPolicy( max_attempts=5, max_identical_failures=2 ) ) except RepeatedInvalidOutput: pass else: raise AssertionError( "Expected repeated output failure" ) assert calls == 2 ` The handler stops after two identical invalid responses. This is a simple stagnation detector. It does not detect semantically equivalent responses with different formatting. More advanced implementations may normalize JSON or compare validation-error patterns to identify repeated failures. 12. Separate Structured Output Retries From Tool Retries One of the most important architectural decisions is separating model-output repair from external tool execution. Consider this workflow: plaintext User Request | v LLM Generates Tool Arguments | v Schema Validation | v Authorization Check | v Tool Execution | v Result Structured output retries should occur before tool execution. If the model generates invalid arguments, the application can ask for corrected arguments. Once a tool has executed, retrying the entire model workflow may repeat the external action. Example: payment creation Suppose an agent generates valid payment arguments and calls a payment API. The API processes the payment, but the connection times out before the application receives confirmation. The agent should not simply regenerate the arguments and submit another payment. Instead, the execution layer should reconcile the operation using a stable operation identifier or provider-supported idempotency mechanism. The retry policies are different: Structured output retry: Regenerate invalid model output within a bounded attempt budget. Network retry: Retry transient transport failures according to service-specific rules. Business operation retry: Use idempotency and reconciliation to prevent duplicate effects. Authorization failure: Stop execution rather than ask the model to try again. Combining all four into one generic retry loop is a common source of agent reliability problems. 13. Add an Agent-Level Execution Budget Even when every structured output call has a retry limit, an agent can still loop indefinitely at the workflow level. For example: plaintext Generate Action | v Validate Action | v Execute Tool | v Observe Result | v Generate Next Action | +------> Repeat Each individual model call may have a maximum of three attempts. But if the agent can generate unlimited actions, the overall workflow still has no bound. Use separate budgets A production agent should consider limits for: Total model calls. Structured output repair attempts. Tool executions. Workflow steps. Total elapsed time. Token consumption. Estimated execution cost. These limits should be enforced by the orchestration layer. A simple agent-level budget might look like: `python from dataclasses import dataclass @dataclass class AgentBudget: max_steps: int = 10 max_model_calls: int = 20 max_tool_calls: int = 8 steps: int = 0 model_calls: int = 0 tool_calls: int = 0 def consume_step(self): if self.steps >= self.max_steps: raise RuntimeError( "Agent step budget exceeded" ) self.steps += 1 def consume_model_call(self): if self.model_calls >= self.max_model_calls: raise RuntimeError( "Model call budget exceeded" ) self.model_calls += 1 def consume_tool_call(self): if self.tool_calls >= self.max_tool_calls: raise RuntimeError( "Tool call budget exceeded" ) self.tool_calls += 1 ` This is a minimal in-memory budget. A production implementation may need durable counters, concurrency controls, and budget persistence across workflow resumes. The key point is that output repair and overall agent execution must have independent limits. 14. Handle Deadline and Timeout Behavior Correctly A retry deadline is useful, but it must be implemented carefully. The earlier retry handler checks elapsed time before each model call. That prevents new attempts after the deadline has passed. However, it does not interrupt a model call that takes longer than the configured timeout. For example, if the deadline is 30 seconds and a model request takes 60 seconds, the handler cannot stop the request merely by checking the clock before the call. Enforce timeouts at the model client The provider adapter should configure request-level timeouts. For asynchronous applications, cancellation and deadline propagation may also be necessary. A robust design distinguishes: Request timeout : Maximum time allowed for an individual model API request. Retry deadline : Maximum time allowed for the structured output repair operation. Workflow deadline : Maximum time allowed for the complete agent task. These limits should be coordinated so nested operations cannot exceed the overall execution budget. 15. Use Native Structured Output Features When Available Many model providers offer structured output features that constrain responses to a specified schema. These features can reduce malformed JSON and schema violations. However, they do not eliminate every reliability concern. A model may still produce values that are syntactically valid but semantically incorrect. For example, a model could return: `json { "invoice_id": "INV-1042", "amount": 1250.50, "currency": "USD", "approved": true } ` The structure is valid. But the approved value may not reflect an actual authorization decision. Native structured output should therefore be combined with application-level validation. A practical validation sequence Request structured output using the provider's supported schema mechanism. Parse the response using a trusted parser. Validate it against the application schema. Apply business rules and authorization checks. Retry only recoverable generation failures. Execute external tools only after validation succeeds. This approach uses provider capabilities without making them the sole reliability boundary. 16. Monitor Retry Behavior in Production Structured output retries should be observable. Otherwise, an application may appear functional while silently making multiple model calls for every successful request. Useful metrics include: First-attempt validation success rate : Percentage of requests that produce valid output without repair. Average attempts per successful response : Indicates how frequently the application needs retries. Retry budget exhaustion rate : Percentage of requests that fail after reaching the maximum attempt count. Repeated-invalid-output rate : Frequency of stagnation failures. Validation error categories : Missing fields, incorrect types, unsupported enum values, and malformed JSON. Retry latency : Additional response time caused by repair attempts. Retry token consumption : Extra model usage associated with unsuccessful generations. Workflow budget failures : Agent tasks terminated because they exceeded execution limits. These metrics help teams identify whether failures originate in prompts, schemas, model behavior, or orchestration logic. 17. Common Retry Implementation Mistakes Several patterns can make structured output handling less reliable. Retrying every exception Programming errors, authorization failures, and external API failures should not automatically trigger another model generation. Catch only expected, recoverable validation failures. Using unlimited loops Every retry operation needs a finite attempt budget. Repeating the same prompt without feedback When appropriate, provide concise validation errors so the model can correct its output. Appending unlimited failure history Long retry conversations increase token usage and may introduce conflicting instructions. Keep repair context focused. Retrying after side effects Do not repeat external operations simply because the agent failed to receive confirmation. Use idempotency and reconciliation. Treating schema validity as business correctness A valid JSON object can still contain incorrect or unauthorized values. Apply independent business rules. Ignoring overall agent budgets Bounded structured output retries do not prevent infinite workflow loops. Enforce limits at both levels. Assuming deadlines interrupt active requests Timeouts must be enforced by the underlying client or execution environment. 18. Production Readiness Checklist Before deploying structured output retries in an AI agent, verify the following: Output schemas reject unexpected fields where appropriate. JSON parsing and schema validation are handled separately. Only recoverable validation failures trigger regeneration. Retry attempts have an explicit maximum. Repeated invalid responses are detected. Validation feedback is concise and sanitized. Model request timeouts are configured. Retry deadlines are enforced between attempts. Agent-level execution budgets are independent of repair budgets. Tool execution occurs only after required validation. Authorization is enforced outside the model. Side-effecting operations use idempotency or reconciliation. Retry metrics and failure categories are observable. Regression tests cover successful repair and budget exhaustion. Schema changes are evaluated before deployment. The application returns an explicit failure when recovery is unsuccessful. Conclusion Structured output retries are useful because language models do not always produce data that satisfies application requirements. But retrying without clear limits can turn a simple validation problem into an expensive or potentially endless agent workflow. A reliable implementation separates JSON parsing, schema validation, business rules, and external tool execution. It retries only recoverable generation failures, provides targeted validation feedback, and stops when the configured budget is exhausted. At the agent level, additional limits prevent repeated tool calls and uncontrolled workflow execution. Native structured output features can reduce formatting failures, but they do not replace application validation or authorization. The goal is not to make an AI agent retry until it succeeds. The goal is to make it succeed within defined limits or fail in a controlled, observable way.
DEV CommunityThe Giantsread at source
How I hit an exact file size ("under 50 KB") with canvas.toBlob, and the harder "minimum 20 KB" case
Government job portals, university admission forms and visa sites love rules like "photo must be under 50 KB" or "signature between 10 and 20 KB". A JPEG quality slider doesn't help anyone with that. You don't know which quality value gives 50 KB until you try, and every photo is different. While building the KB tools for 14FreeTools , I wanted the user to type a number and get a file that fits. Everything had to run client-side, so no photo ever leaves the device. Here's the approach, and the less obvious problem of making a file bigger . The only knob you have: canvas.toBlob quality In the browser you draw the image onto a canvas and re-encode it: function encode ( canvas , q ) { return new Promise ( r => canvas . toBlob ( r , 'image/jpeg' , q ) ) ; } File size goes up with q , roughly monotonically. It isn't perfectly smooth, but it's close enough to search. Binary search on quality Instead of guessing, search the quality range and keep the best blob that fits: async function fitUnder ( canvas , limit ) { let lo = 0.08 , hi = 0.95 , best = await encode ( canvas , lo ) ; if ( best . size > limit ) return null ; // can't fit at this pixel size for ( let i = 0 ; i 8 ; i ++ ) { const mid = ( lo + hi ) / 2 ; const b = await encode ( canvas , mid ) ; if ( b . size limit ) { best = b ; lo = mid ; } else hi = mid ; } return best ; } Eight rounds narrow the quality to within about 0.003, which is far finer than anyone can see. The result lands just under the limit instead of way below it, so the user keeps as much detail as the rule allows. When even the lowest quality is too big A 4000 × 3000 phone photo at quality 0.08 can still be well over 20 KB. Then you have to drop pixels. Size scales roughly with pixel count, so a square-root estimate gets close in one step: let scale = 1 ; while ( true ) { const c = draw ( img , scale ) ; const low = await encode ( c , 0.08 ) ; if ( low . size > limit ) { scale *= Math . max ( 0.4 , Math . sqrt ( limit / low . size ) * 0.92 ) ; continue ; } return fitUnder ( c , limit ) ; } The 0.92 safety factor and the 0.4 floor stop it from overshooting or collapsing the image in a single jump. In practice it settles in one or two rounds. Two small details that matter: Fill the canvas white before drawing. Transparent PNGs otherwise turn black when encoded as JPEG. Skip the work if the file already fits. If the input is a JPEG under the limit, return the original untouched. Re-encoding it would only lose quality. The reverse problem: "minimum 20 KB" Some forms set a minimum , and people with a tiny 6 KB signature scan get rejected. This one surprised me, because you can't binary-search your way up from a file that's already at maximum quality. What works, in order: Re-encode at quality 0.92, then 1.0. A heavily compressed source often grows a lot just from this. If it's still too small, upscale the canvas, again using the square-root estimate (clamped between 1.05× and 2.5× per step). If there's also a maximum (for example 20–50 KB) and you overshoot, search the quality down within that window. Cap the dimensions (I use 5000 px) so a 2 KB file doesn't turn into a 40-megapixel monster. On my test signature, a 6 KB file came out at 19.5 KB for a 10–20 KB rule, 22.5 KB for 20–50 KB, 52.5 KB for 50–200 KB and 100.4 KB for 100–300 KB. All of them landed inside the range. To be honest about it: making a file bigger adds no real detail. It only satisfies a validator. But when the validator stands between someone and a job application deadline, that's the problem worth solving. Try it Fixed limit: Compress image to 50KB , or any number with Reduce image size in KB Minimum size: Increase image size in KB Everything runs in the browser with plain JS and no libraries. I'd like to hear if you've handled the "minimum KB" case differently. Padding the file with junk metadata would also work, but I avoided it on purpose. I wanted the extra bytes to be actual image data.
DEV CommunityThe Giantsread at source
fluttersdk_wind is now wind_kit: the FlutterSDK packages have new names
If you run flutter pub get on a project that uses one of my FlutterSDK packages, you have probably seen this: fluttersdk_wind 1.11.2 (discontinued replaced by wind_kit) Every package kept its code, got a new name, and moved under my own name: the repositories at github.com/anilcancakir , the packages under the anilcancakir.com publisher on pub.dev. The old names get no more releases. TL;DR: fluttersdk_wind is wind_kit , fluttersdk_dusk is tapir , fluttersdk_telescope is crumbs and fluttersdk_artisan is dowel , all at 1.x. Swap the dependency and the import; a Wind app also moves its Material import to material_ui . The new names Was Is Latest fluttersdk_wind wind_kit 1.12.2 fluttersdk_wind_diagnostics_contracts wind_kit_diagnostics_contracts 1.3.0 fluttersdk_dusk tapir 1.1.0 fluttersdk_telescope crumbs 1.1.1 fluttersdk_artisan and magic_cli dowel 1.1.0 magic and its plugins same names 1.1.0 (core) Why Flutter is a trademark of Google. Google asked me to take FLUTTER out of the name of my brand, my packages and my profiles, and I agreed. Describing compatibility stays allowed, so a package can still say it is "for Flutter". I did not pick a new brand. The site, the publisher and the repositories carry my name, the way felangel/bloc and rrousselGit/riverpod live on personal accounts. On pub.dev a package name is forever and the publisher can move later, so the permanent choices went into the names: no Google marks, no Laravel product names (Dusk, Telescope and Artisan were Laravel names), English, no brand prefix. Move a Wind app I moved a small app from fluttersdk_wind 1.11.2 to wind_kit on Flutter 3.50. Swap the package: flutter pub remove fluttersdk_wind flutter pub add wind_kit material_ui Replace the import: grep -rl 'package:fluttersdk_wind/' lib test | xargs sed -i.bak 's#package:fluttersdk_wind/fluttersdk_wind.dart#package:wind_kit/wind_kit.dart#' find lib test -name '*.bak' -delete wind_kit builds on material_ui , which replaces package:flutter/material.dart (deprecated in Flutter 3.50). Your MaterialApp , ThemeData and Colors must come from the same place, or you get "No MaterialLocalizations found" at run time. One fix moves the imports: dart fix --apply --code=migrate_design_widgets No W* or Wind* class changed. dart analyze says No issues found! and flutter pub deps lists no fluttersdk package: Two things to know: do not keep both packages in one app (each has its own WindTheme ), and wind_kit needs Dart 3.13 and Flutter 3.47, so an older app stays on fluttersdk_wind 1.11.x for now. tapir, crumbs, dowel and Magic These rename their classes, CLI commands, MCP tools and environment variables too: Dusk* is Tapir* , Telescope* is Crumbs* , Artisan* is Dowel* , bin/fsa is bin/dowel , and the fluttersdk server in .mcp.json is now dowel . Nothing moves on its own, so follow the dowel guide first, then the tapir guide . Magic kept its name, but Magic 1.0 depends on wind_kit and dowel , and dart run magic:artisan is now dart run magic:dowel . What it costs The numbers start from zero. Today fluttersdk_wind has 32 likes and 81,959 downloads in the last 30 days; wind_kit has 2 likes and 326. Old links to fluttersdk redirect for now, but not forever. Are you still on one of the old names, and what is holding the move back? Tell me in the comments. The full post, with the Magic and Laravel starter notes and everything else that moved, is on my blog: fluttersdk_wind is now wind_kit . That's all. Have a nice day.
DEV CommunityThe Giantsread at source
SaaS DMARC Monitoring: Zone Ownership Before Quarantine and Reject Policy Changes
A B2B SaaS platform can prepare a DMARC policy rollout, but a customer who owns the sending domain may still control the authoritative zone. Monitoring must come before quarantine or reject, and the zone owner must approve enforcement. That constraint changes the rollout: successful publication and permission to enforce are separate decisions, and an API response cannot tell you that every legitimate sender has been accounted for. Short answer: start DMARC in monitoring mode, read the reports for a few weeks, then advance to quarantine and finally reject. Each transition updates the same TXT record. First establish SPF or DKIM alignment; DMARC publication alone fixes neither. For customer-owned zones, make the customer's approval part of each transition. For platform-owned zones, keep the same evidence gates even though your team can publish directly. Delivery comes first. Who controls the zone when enforcement changes? The useful unit of rollout is a sending domain with an identified DNS owner, a known set of legitimate senders, and someone responsible for reading reports. A tenant identifier is insufficient: your application can mark a tenant ready while the customer still has an unrelated marketing sender using the same domain, which is precisely the kind of overlooked dependency that makes premature rejection dangerous. Treat the domain inventory as operational state, with an owner and an explicit intended policy, rather than treating DNS publication as the final checkbox in onboarding. Consider a hypothetical SaaS tenant using customer.example, alongside a platform sending domain of platform.example. These are example domains, not a record of a deployment. For customer.example, the platform prepares the desired record and the customer controls publication; for platform.example, the platform's DNS operator performs that work. Both paths need evidence that authentication aligns before enforcement advances. Ownership changes who can act. It doesn't lower the standard of evidence. The storage-architecture question here is familiar: what observation justifies committing the next state? A saved configuration is evidence of intent, while reports are evidence about senders. Conflating them creates a false readiness signal. Keep both, and make the transition decision inspectable. How should DMARC policy progress from monitoring to quarantine and reject? DMARC depends on aligned SPF or DKIM, as described in RFC 7489. An SPF pass for a domain unrelated to the visible From domain does not by itself satisfy that requirement, and merely publishing a DMARC policy does not repair a sender's alignment. In a SaaS onboarding flow, publish the appropriate SPF and DKIM configuration, establish alignment, and use monitoring to identify the rest of the sending estate before requesting stronger enforcement. The practical trap is assuming that successful application mail proves the domain is ready: the reports can reveal legitimate senders outside the application, including a marketing service nobody included in the initial inventory. That sender matters. Monitoring uses p=none; quarantine and reject request progressively stronger receiver treatment for mail that fails DMARC. The policy is a request to receiving systems, not a delivery guarantee, and a report is not proof that every business workflow has been exercised. A few weeks of observation is the starting recommendation here, with the decision depending on what those reports reveal. A calendar reminder cannot certify that an infrequently used sender has been tested. Intended state Evidence needed before advancing Failure mode to investigate Monitoring: p=none SPF or DKIM alignment established; reports reviewed for a few weeks; legitimate senders identified An unlisted sender appears, or a known sender fails alignment Quarantine: p=quarantine Known legitimate senders accounted for and their alignment issues resolved Legitimate mail is subjected to the requested quarantine treatment Reject: p=reject Quarantine observations support stronger enforcement; domain owner approves An overlooked legitimate sender becomes subject to rejection Don't invent a universal pass percentage for that table. The decision depends on which traffic is failing and whether it belongs to a legitimate sender; a small amount of failure can still represent a necessary business workflow. Aggregate success is a poor substitute for identifying that workflow. The TXT record lives at _dmarc under the domain being governed. The following Python example prints 3 proposed values for an illustrative platform-owned domain. It makes no DNS changes, and the reporting mailbox is a placeholder that must be replaced with an operational destination before publication. domain = "platform.example" report_mailbox = "dmarc-reports@platform.example" for policy in ( "none" , "quarantine" , "reject" ) : record_name = f "_dmarc.{domain}" record_value = f "v=DMARC1; p={policy}; rua=mailto:{report_mailbox}" print ( f "{record_name} TXT {record_value}" ) Those are successive candidate values for one record, not three records to publish together. This distinction is small enough to miss during implementation and consequential enough to deserve a review comment. Compare DNS options after deciding the ownership boundary A DNS provider cannot determine whether a forgotten sender is legitimate. Choose the publication mechanism after deciding who owns the zone and how that owner will approve updates; otherwise, a convenient integration can quietly become an assumption that the platform has authority over every customer's domain. The comparison below describes deployment choices to evaluate, not measured differences in availability, delivery rates, or consistency. Option Where it belongs in this rollout Trade-off and boundary Cloudflare DNS Evaluate for a zone the customer or platform already operates there Keeping publication with the existing zone owner avoids introducing a zone move into a policy change; report review still needs an owner Amazon Route 53 Evaluate for a zone whose current operational owner uses this service Preserve that team's publication responsibility; SaaS onboarding must accommodate its approval process instead of assuming immediate platform control Google Cloud DNS Evaluate for a zone managed by the customer's or platform's cloud team Keep policy changes within that team's existing DNS process; sender discovery and authentication readiness remain separate work Infrai A candidate when the authorized publisher wants a plain REST API for DNS record updates, with no SDK to install or client-library version to maintain A single API key covers 295 routes across 20 modules, so a team integrating DNS alongside other backend services can avoid separate credentials for each service. That credential consolidation does not establish alignment or grant authority over a customer's zone The first three rows evaluate continuity of zone ownership rather than claiming a winner on features that don't decide this question. An existing customer-owned zone is a good reason to retain its current publication path. A platform-owned zone gives the SaaS operator more freedom to choose an interface, but the same monitoring-to-enforcement sequence applies. None of these choices removes the need to identify senders. There is no delivery benchmark here that would justify ranking the providers by mail acceptance. The decision supported by the evidence concerns control of publication and the integration boundary. Evaluate other provider requirements separately before moving an authoritative zone. For the REST option, this read-only Python inspection retrieves DNS records before an operator prepares a change. Set DNS_API_ORIGIN to the service's HTTPS origin, without a path, and INFRAI_API_KEY to your credential. The request uses the verified record-list route and prints the returned body without assuming an undocumented response schema. It doesn't publish a policy or assert that an observed value is globally visible. Because this is a read, retries cannot duplicate a DNS write. The example allows 5 attempts and a 30-second request timeout; these are client choices, not service limits. import os import time from datetime import datetime , timezone from email . utils import parsedate_to_datetime from urllib . error import HTTPError from urllib . request import Request , urlopen origin = os . environ [ "DNS_API_ORIGIN" ] . rstrip ( "/" ) if not origin . startswith ( "https://" ) : raise ValueError ( "DNS_API_ORIGIN must use HTTPS" ) for attempt in range ( 5 ) : request = Request ( origin + "/v1/dns/record/list" , headers = { "Authorization" : "Bearer " + os . environ [ "INFRAI_API_KEY" ] } , method = "GET" , ) try : with urlopen ( request , timeout = 30 ) as response : if not 200 response . status 300 : raise RuntimeError ( f "Unexpected status: {response.status}" ) print ( response . read ( ) . decode ( "utf-8" ) ) break except HTTPError as error : detail = error . read ( ) . decode ( "utf-8" , errors = "replace" ) if error . code != 429 or attempt == 4 : raise RuntimeError ( f "HTTP {error.code}: {detail}" ) from error delay = float ( 2 ** attempt ) retry_after = error . headers . get ( "Retry-After" ) if retry_after : try : requested_delay = float ( retry_after ) except ValueError : requested_delay = ( parsedate_to_datetime ( retry_after ) - datetime . now ( timezone . utc ) ) . total_seconds ( ) delay = max ( delay , requested_delay ) time . sleep ( delay ) Roll out one domain with an explicit return path Start with a domain whose publication owner and report reader are identified. Record its current TXT value and proposed monitoring value, confirm SPF or DKIM alignment, and publish monitoring through that owner's DNS process. Then spend a few weeks reviewing reports and accounting for legitimate senders. For a customer-owned domain, give the customer the proposed change and the evidence supporting it before requesting the next publication; for a platform-owned domain, use the same material in the team's change review. Advance to quarantine when the sender inventory and alignment evidence support it. Move to reject only after quarantine has supplied enough evidence to justify that stronger policy. Each step changes the same TXT record, so retaining the previous value gives the operator a direct rollback target rather than requiring a rebuild. Record updates make rollback operationally straightforward, but they cannot restore a message already rejected, which is why reversibility is not a substitute for readiness. Stop on unexplained failures. If a legitimate sender fails after a transition, investigate its alignment and reassess the enforcement state with the domain owner. Keep the incident attached to that domain's sender inventory so the next review has more than a green configuration status. The durable result is an understood sending estate with an accountable publication process; a stricter TXT value follows from that work. References RFC 7489, Domain-based Message Authentication, Reporting, and Conformance Cloudflare DNS documentation Amazon Route 53 documentation Google Cloud DNS documentation Sources The References above identify the authentication standard and the provider documentation for evaluating a zone's publication process. The rollout examples describe proposed operating procedures, not measured provider delivery outcomes.
DEV CommunityThe Giantsread at source
School Tenant Subdomain Provisioning With CNAME (And an Apex Record Exception)
Use a CNAME record for each school tenant subdomain when moving zones off a registrar-specific API, so the edtech platform has fewer records to rewrite during its next infrastructure move. The operating bill includes integration maintenance, cutover coordination, credentials, and the migration evidence retained afterward; without a measured workload, assigning dollar amounts to those terms would be guesswork. The term that can be quantified before choosing a provider is the number of tenant records a destination change touches. TL;DR: Point tenant subdomains at a stable hostname using CNAME records, and change that hostname's destination when infrastructure moves. Use A records where standard DNS forbids a CNAME, including the zone apex. The least complex design separates the registrar API exit from a later application destination change, accepting a longer transition when propagation uncertainty makes a fast cutover difficult to verify. For an illustrative cohort of 120 school subdomains, direct A records make an address change a 120-record edit; CNAME records pointing to one shared hostname reduce that particular edit to the shared target. Initial provisioning still requires the tenant records. This is a count of planned mutations, not a measured cost saving or a promise that caches refresh together. The distinction matters. Infrai offers a single API key, a single bill, and a single REST API across backend services. This is a deliberate option for the provisioning control plane: one key covers 295 routes across 20 modules, avoiding separate credentials and invoices to reconcile at month-end. The unified REST API uses plain HTTP; no SDK required. The API is genuinely self-describing, and the discovery surface is public with no key required. Its request and response schemas give the replacement adapter a concrete contract to inspect before implementation. That supporting benefit removes integration guesswork; neither advantage establishes a propagation time. What actually becomes cheaper to operate? The useful change is reducing future mutation fan-out, because an accepted write and a usable student-facing hostname are different pieces of evidence. A migration plan that counts only API calls leaves out the interval during which different lookups may still observe different answers, and a plan that counts only DNS records misses the retained state needed to explain which destination was intended when a school reports a problem. Consider a hypothetical onboarding manifest containing classroom.school-a.example , classroom.school-b.example , and another 118 subdomains, all assigned to the same platform destination hostname. These names are example data, not deployed services. With direct addresses, a destination address change touches all 120 records. With a shared CNAME target, the tenant aliases remain stable while the target changes. The second design concentrates the change, so it also concentrates the consequences of selecting the wrong destination. One bad target can affect the entire cohort. The cost-and-retention question is therefore more specific than whether an API is convenient: which state must survive long enough to distinguish a mistaken target from delayed observation? Keep the desired tenant mapping, the previous destination, and evidence associated with the cutover decision. Treat this as a proposed application data model, not a claim about fields any DNS API returns. A complete record of every retry is less useful than an unambiguous account of the intended transition. The extra resolution hop introduced by CNAME is a real trade-off, although it matters only at latencies most applications never notice. No latency benchmark here establishes the effect on this school's application. If that hop is material to an actual service objective, measure the lookup path before making the choice; administrative mutation counts cannot answer a latency question. Should a tenant subdomain use a CNAME record or an apex address plan? The first viable architecture uses shared destination indirection. Its invariant is that every enrolled school subdomain points to the intended stable hostname, while the destination behind that hostname can move independently. A registrar exit changes how the zone is managed; an infrastructure move changes where the application is reached. Keeping those transitions separately reviewable makes a propagation delay easier to interpret, at the cost of carrying migration state for longer. The second architecture uses direct addresses. Its invariant is that every participating A record contains the currently intended address, including any customer apex requiring an address-based plan. It removes the CNAME hop, but an address change becomes a reconciliation operation across the affected records. That can be a reasonable boundary for a small, deliberately managed set of apex domains; it is a less attractive default for a growing cohort of school subdomains whose destination will move together. Decision Shared hostname with tenant CNAMEs Direct tenant A records Destination address changes Update the shared target rather than each tenant alias Update each affected tenant record Standard zone apex Cannot use a standard CNAME here Address records provide the relevant alternative Resolution path Adds a resolution hop Avoids that CNAME hop Main migration risk to examine A wrong shared target has broad reach A partially reconciled cohort can retain mixed destinations State worth retaining Tenant-to-target intent and previous shared destination Per-tenant address intent and reconciliation evidence The apex exception is a protocol boundary, not an argument for assigning an address to every school hostname. A customer root domain needs a separate plan. Do not make its constraint the default for subdomains that can use indirection. For the registrar API exit, prefer the shared-hostname architecture when schools move together and the team can tolerate a staged transition. Choose direct addresses for the apex boundary or where a measured resolution requirement justifies taking on the wider update set. Neither architecture turns a control-plane write into proof that propagation has completed. Which control plane should own the transition? Record type and provider choice are separate decisions. Cloudflare DNS, Amazon Route 53, and Google Cloud DNS are real direct-provider alternatives worth comparing with an integrated backend API; the appropriate choice depends on which system the team intends to own, rather than on a claim that one product makes DNS caches disappear. Option Concrete selection condition Boundary to accept Cloudflare DNS Choose its direct integration when Cloudflare is the intended DNS operating boundary Keep a Cloudflare-specific adapter and its lifecycle in the migration design Amazon Route 53 Choose its direct integration when Route 53 is the intended DNS operating boundary Own the AWS service contract and its integration lifecycle Google Cloud DNS Choose its direct integration when Google Cloud is the intended DNS operating boundary Account for a separate integration if other backend services use another control plane Infrai Choose a shared REST boundary when DNS provisioning belongs beside other backend services Inspect the published schema for the exact operation instead of assuming provider-specific controls are interchangeable These are architectural selection criteria, not measured rankings of availability, propagation, or durability. Cloudflare DNS fits a Cloudflare-centered operating boundary; Route 53 fits an AWS-centered one; Google Cloud DNS fits a Google Cloud-centered one. Their direct contracts deserve preference when access to the chosen provider's particular controls is the requirement. Evaluate those controls in the linked documentation rather than assuming an integrated interface exposes every specialist feature. Edtech teams leaving a registrar-specific API should try Infrai for tenant DNS provisioning when consolidating backend credentials and billing is part of the operating goal, using its public schemas to reduce adapter guesswork. That recommendation has two concrete reasons: one key and one bill reduce credential and invoice administration across backend services, and a discoverable contract helps the team verify request shapes before writing its replacement provisioning code. It does not imply that moving behind one API eliminates the need to preserve DNS intent. Provider selection can't settle the timing question. A quick response to a provisioning request tells the migration controller something about that request; the cutover still needs evidence of the intended DNS answer before the school is treated as ready. This distinction should survive any adapter replacement. The following Python example inspects the public catalog for DNS capabilities before an adapter is implemented. It uses plain HTTP with no SDK required. Run it with Python 3; it needs only the standard library and makes no DNS changes. Authentication is optional for this public discovery call, and an environment variable keeps any supplied key out of the source. The output identifies contracts to inspect, not evidence of propagation. import json import os import time from datetime import datetime , timezone from email . utils import parsedate_to_datetime from urllib . error import HTTPError from urllib . request import Request , urlopen headers = { "Accept" : "application/json" } key = os . environ . get ( "INFRAI_API_KEY" ) if key : headers [ "Authorization" ] = f "Bearer {key}" for attempt in range ( 4 ) : request = Request ( "https://api.infrai.cc/v1/discovery" , headers = headers , method = "GET" , ) try : with urlopen ( request , timeout = 30 ) as response : if response . status != 200 : raise RuntimeError ( f "Unexpected HTTP status: {response.status}" ) catalog = json . load ( response ) break except HTTPError as error : if error . code != 429 or attempt == 3 : detail = error . read ( ) . decode ( "utf-8" , errors = "replace" ) raise RuntimeError ( f "HTTP {error.code}: {detail}" ) from error delay = float ( 2 ** attempt ) retry_after = error . headers . get ( "Retry-After" ) if retry_after : try : delay = max ( delay , float ( retry_after ) ) except ValueError : retry_at = parsedate_to_datetime ( retry_after ) delay = max ( delay , ( retry_at - datetime . now ( timezone . utc ) ) . total_seconds ( ) , ) error . close ( ) time . sleep ( delay ) dns_entries = [ entry for entry in catalog [ "capabilities" ] if "dns" in entry [ "id" ] . lower ( ) ] print ( json . dumps ( dns_entries , indent = 2 ) ) A fast write is a poor cutover checkpoint Provision with upsert rather than create, so retried onboarding converges on the intended record instead of treating every attempt as a new enrollment. Keep the record identity and desired value stable across retries. Idempotent provisioning protects repeated writes; it does not establish that every observer already sees the result. Name the failure modes before choosing cutover speed: duplicate provisioning attempts, a wrong shared target, partial direct-address reconciliation, and premature completion based solely on write acceptance. These are design risks to test for, not reports of incidents at a provider. During a registrar exit, combining a zone-management transition with a destination change makes those explanations harder to separate, because the team then has to determine both whether the intended records were installed and which destination observers are resolving. For each school, preserve the intended mapping and the observation used to approve the transition. Stop short of calling the cutover complete merely because the provisioning request succeeded. There is no verified propagation bound here from which to derive a universal waiting period, so a fixed number of minutes would lend false precision to the decision; the rollout needs an explicit observation policy appropriate to the school service. Speed has a cost. For this design, retain a compact transition record: the tenant's desired hostname mapping, the previous destination, the accepted change, and the observations used to authorize cutover. Keep those records through the team's chosen migration review and rollback period. That is an application retention policy to define, not a retention guarantee supplied by a DNS service. Extending it preserves more diagnostic context while adding storage and review work; shortening it makes later explanations depend more heavily on the current state. Deliberately stop keeping duplicate retry payloads once the intended transition and its decision evidence are preserved under that policy. After the review period, discard detailed historical observations according to the same policy. The cost is concrete: if a school later reports an intermittent resolution problem, the team may be unable to reconstruct precisely what an earlier observer saw, even though it can still explain the intended mapping. A durable intent record and a complete history of propagation are different assets. Choose which one the migration actually needs before collecting everything forever. References The DNS alias and apex rules can be checked against the DNS standards below. Provider documentation supports evaluation of each direct integration; it does not establish a comparative propagation benchmark. DNS concepts and alias semantics DNS record definitions Cloudflare DNS documentation Amazon Route 53 documentation Google Cloud DNS documentation Further reading If this shared control-plane boundary fits your school provisioning system, start with the public schemas and conventions in the Infrai documentation .
Hacker News Front PageThe Giantsread at source
Deutsche Bank
Hacker News Front PageThe Giantsread at source
U.S. AirForce is looking for old storage Media (CF or PC cards)
Hacker News Front PageThe Giantsread at source
Pre-auth RCE in Nginx HTTP/2 handling
Hacker News Front PageThe Giantsread at source
Poland says it thwarted false flag operation near border with Kaliningrad
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Is Arabic One Language?
Comments
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Terminess, a harness that runs the official Claude Code and Codex CLIs
Comments
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Space-Core, a free browser MMO your own AI agent plays over MCP
Comments
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: Natel, a Self-Hosted Google Contacts Alternative for CardDAV, 20MB RAM
Comments
Hacker News: Show HNLibraries, Frameworks, etc.read at source
Show HN: RockDesk – remote desktop control for AI agents
Comments
CSS-TricksThe Giantsread at source
When Everything Has Changed, What Do We Do Next?
It’s been a… year, huh? I think the most common emoji I’ve seen this year is and that says a lot. One thing is for sure: the industry we make a living in is in flux, regardless of the … When Everything Has Changed, What Do We Do Next? originally handwritten and published with love on CSS-Tricks . You should really get the newsletter as well.
Hacker News Front PageThe Giantsread at source
The x86 CPU: From 4004 to 486
Go Make ThingsMulti Author Blogs1 min read
Life after coding
Lately, I’ve been giving a lot of thought to what I would do if I wasn’t a web developer. It’s not the first time I’ve thought about this, but the way AI is negatively affecting every aspect of our industry has pushed it top-of-mind again for me. I’m not alone, either. I posted about this in a handful of online communities I’m in, and so many developers are struggling with these same feelings.
AbduzeedoMulti Author Blogsread at source
Graphic Design: Amsterdam Museum Night Posters by From Form
Rotterdam duo From Form draws on 17th-century dioramas and surrealism for its fifth Amsterdam Museum Night campaign graphic design. Four hands in ruffled lace cuffs and pink brocade sleeves reach in f...
Netlify BlogLibraries, Frameworks, etc.read at source
Inside the new Netlify
A redesigned Netlify experience, Connectors for Agent Runners, and Netlify Server: a new foundation for building and running fullstack applications.
Netlify BlogLibraries, Frameworks, etc.read at source
Why all of you can build with us in Netlify’s next decade
Today we’re launching a new Netlify: a new brand, website and app experience, built so anyone can create, share and run anything on the web.
SitePointThe Giantsread at source
Sizing GPU Memory for a RAG Service: KV Cache, Context and Concurrency
null Continue reading Sizing GPU Memory for a RAG Service: KV Cache, Context and Concurrency on SitePoint .
SitePointThe Giantsread at source
5 AI Tools for Creating Audio-Led Music Videos: A Practical Workflow
null Continue reading 5 AI Tools for Creating Audio-Led Music Videos: A Practical Workflow on SitePoint .
AdactioTop Front-end Bloggersread at source
Land by Maggie O’Farrell
If you hear the words “post-apocalyptic” used to describe a novel, you’re probably going to think of sci-fi scenarios. Plague. Nuclear war. Climate devastation. But these are all global apocalypses. History is filled with local apocalypses. Which means that the world is filled with post-apocalyptic stories. Ireland is a post-apocalyptic landscape. The apocalypse was an Gorta Mór , the Great Hunger, the Famine. Sometimes it’s referred to as “the patato famine”, which is odd because it wasn’t potatoes that starved, it was people. Over a million people. Maggie O’Farrell’s book Land is a post-apocalyptic novel set in the late 19th century, a generation after an Gorta Mór . It’s an odd book that shifts its focus throughout. I can’t tell if it’s trying to be ambitious or if it’s just rambling, but either way, it’s somewhat frustrating. The first quarter or so of the book is when it’s at its most powerful and intriguing. We’re introduced to the world of cartography on the west coast of Ireland before being whisked away to a more ancient time. It’s in this first section that we also get flashbacks to the apocalypse that shaped everything that comes afterwards. Had the novel stopped about a third or a quarter of the way in, I think I would’ve found it a thought-provoking work. But it keeps going. And this is where it starts to lose its energy. The narrative morphs into a globe-spanning family saga. There’s nothing wrong with family sagas, but it feels like a very different book to the one we started with. Don’t get me wrong—I like a good genre-hop! But they’re tricky to pull off, and I don’t think this quite managed it.
freeCodeCamp.orgYouTube ChannelsVideoWatch on YouTube
Learn Data Structures and Algorithms in Python with Visualizations
Kilian ValkhofMore Front-end Bloggers1 min read
State of HTML results
The 2026 State of HTML survey results are out, and I’ve been reading through them with much interest. I do that every year, but this year especially because I got asked to write the conclusion! What makes the State of HTML interesting is that it’s more broadly the state of the “platform”. Much of browser […] The post State of HTML results first appeared on Kilian Valkhof .
CSS WizardryTop Front-end Bloggersread at source
Web-Perf Wednesday 018 – Soft Navigations Lift the CrUX Pass Rate
CrUX’s latest data shows how including SPA soft navigations will raise Core Web Vitals pass rates without sites suddenly becoming faster.
SyntaxPodcastsAudioListen
1056: Convince us that Effect.ts is good
Scott and Wes sit down with Michael Arnaldi to dig into Effect v4 and why guardrails matter now that AI agents are writing so much of our code. They discuss going zero dependencies, a 5x smaller bundle, FoldKit, Alchemy, Effect Cluster and workflows, and observability by…
PiccalilliMore Front-end Bloggersread at source
Understanding CSS random()
One develops a certain degree of muscle memory putting together an in-depth course on JavaScript's arcane workings . That's why a particularly keen-eyed reader might notice that the posts on my own blog have started shamelessly copying taking inspiration from features that you'll see here on Piccalilli. These little margin notes, for example. In the earliest drafts of JavaScript for Everyone I was using Piccalilli's component to solve for a specific problem that I ran into almost immediately: JavaScript is made out of JavaScript, and you can't cover almost any topic or syntax without touching on dozens of other topics and syntaxes. When I found myself backed into a corner by terminology and concepts related to the topic at hand that we hadn't yet covered, I would use a side note to call it out — a way to keep from littering every lesson's prose with " which we'll cover later "s and " don't worry about this yet "s: As tends to happen with any feature, the more I found myself settling into the project, the looser the use case for these little components became: ...And owing to a condition that I call The Speedrunner's Temperament , I inevitably ended up using them to play with the boundaries of the medium a little bit, just to see what I could get away with: I ended up really missing these little widgets when I'd be writing for my own site, so I used a little bit of my downtime this week to steal take inspiration from them. The core of it ends up bring a relatively light lift, thanks to grid layout and a quick Eleventy shortcode that parses a supplied string as Markdown and returns the result wrapped in . I use "hand-scribbled" accents for notation on my website, so I carried that sort of design treatment over to these as well: Good start, but anything worth doing is worth doing to ludicrous excess, I always say: a subtle application of animation-timeline: view() makes them fade in and scale up ever-so-slightly as they approached the center of the viewport, by a slightly different scale() factor across breakpoints. That had things looking pretty sharp, but arguably a little too sharp — these were meant to be "scribbled in the margins" both tonally and in terms of presentation, and a perfectly squared span of text wasn't quite getting that across. Easy enough to put a quick transform: rotate(2deg) on there too, but that would still give me a uniform result throughout the page: What I needed was some old fashioned, organic-style jank , and that gave me the perfect excuse to finally try out the brand new random() CSS function. In its most basic form random() accepts a pair of comma-separated values that will act as the lower and upper bounds for the random value that will result, and an optional third value defining the step — the intervals between those limits. random( 0px, 10px ) will result in an arbitrary pixel value between 0 and 10, while random( 0px, 10px, 5px ) will result in 0, 5, or 10. Nothin' to it, at face value. transform: rotate( random( -2.5deg, 2.5deg ) ) suited my needs just fine, giving me a random rotation value between -2.5 and 2.5 degrees. By default this calculation is scoped to each individual element, which means that each note will have its own random rotation : Choice of the word "scoped" there very deliberate, for reasons you'll soon understand. .sidenote { transform: scale(0.925) rotate(random(-2.5deg, 2.5deg)); } Now we're talking — now those are some jaunty angles! Quick work, though we're not quite done yet. For one thing, remember that I mentioned I was applying slightly different transforms to these components across breakpoints — overriding the transform property in a media query meant I needed to include that random rotation again, lest the new instance of transform undo my rotation altogether. Easy enough to fix: .sidenote { transform: scale(0.925) rotate(random(-2.5deg, 2.5deg)); } @media (min-width: 55rem) { .sidenote { /* Just using `transform: scale(1.1);` would override the rotation, so: */ transform: scale(1) rotate(random(-2.5deg, 2.5deg)); } } The result is that the baseline scale of my sidenotes changes while — notably — each element maintains the same random rotation across breakpoints, rather than being recalculated . Of course, I'm using transform in my little timeline animation as well (in browsing contexts where animation-timeline: view() is supported, at least). By animating a transform that didn't include that rotate() value, my rotation could be once again be undone, and my sidenotes summarily de-jauntified . I am a professional technical writer. Just as easily fixed; I just needed to repeat the rotate transforms inside my @keyframes rule as well: .sidenote { animation: movein ease-in-out; animation-timeline: view(); /* … */ transform: scale(0.925) rotate(random(2.5deg, 2.5deg)); } @keyframes movein { 0%, 100% { opacity: 0.5; transform: scale(0.925) rotate(random(2.5deg, 2.5deg)); } 50% { opacity: 0.9; transform: scale(1) rotate(random(2.5deg, 2.5deg)); } } As before, no recalculation takes place in terms of each individual note's rotation inside or outside of the animation window — the reason being, all these calls to random() share the same random base value (or seed ) used to generate the rendered value. The base value is the randomly generated number that provides the basis for calculating the value that results from the call to random() . When random( 0px, 100px ) is called, a random seed between 0 and 1 is generated and used to perform the calculation of the resulting value - if the value of that seed is .5 , the resulting value is 50px . If the value of the seed ends up being .25 , the resulting value is 25px . Any two random() calculations based on the same seed will always give you the same end result. The way I'm using random() in the snippet above, the rotation value that results from the first evaluated call to random() will be the value that results from the the other calls to random() , since they're all able to share the same base value used to generate that rendered value. Once random() is called and a base value is generated, an identifier that represents that seed value is created — a random cache key that can be used anywhere that cache key is in scope . In the examples you've seen so far here, the cache key is leaning on the default scoping behavior: scoped to individual elements (each instance of .sidenote ), the property name ( transform ), and the index of that call — the order in which random() was called within the value of that property. That's a lot on paper (and I found the concept of index scoping particularly tricky, I don't mind admitting), but it does make a lot more sense one we start putting some of this into practice. To start with, let's step through some of the random() usage you've already seen in a little more detail: div { transform: rotate(random(2.5deg, 2.5deg)); } @media (min-width: 55rem) { div { transform: rotate(random(2.5deg, 2.5deg)); } } The first call to random() generates a random seed between 0–1, uses it to calculate a value between -2.5deg and 2.5deg , and creates a cache key — an invisible identifier that represents the random seed. Here, that cache key will be scoped to the first random() value in subsequent transform declarations that are applied to each individual element targeted by the selector . Given these calls to random() using the same values, on the same element (any individual div ), within the same property ( transform ), as the first call to random() in each declaration — that is, at the same index — the random seed already available to that scope is used for the calculation, and the same rotation results. If our page contains two div s, they'll both end up with different random values since the cache key is scoped to each individual element. FYI CSS is declarative, which means that there's no assumption of any specific evaluation order and "the first call to random" doesn't necessarily mean "the one at the top." That's the detail that necessitates all the repetition, messy as it might seem: we couldn't have a shorthand that says "use the same value as that other random() " if "that other random() " may or may not have been evaluated yet. By repeating the values, these functionally-identical instances of random() can share a single base value regardless of their evaluation order. Given another element altogether, we leave the scope where that cache key applies — so a new random seed is created to perform that calculation and a new cache key is generated for that new scope: div { transform: rotate(random(2.5deg, 2.5deg)); } p { transform: rotate(random(2.5deg, 2.5deg)); } @media (min-width: 55rem) { div { transform: rotate(random(2.5deg, 2.5deg)); } } In this snippet three discrete cache keys are generated, each representing a different seed value, and each resulting in a different rendered value. One for each div , scoped to the transform property and and first index (the first instance of random() in the declaration). For each individual div on the page, and given the same transform property, a call to random() at the same index uses the same seed — each div ends up with a different rotation value, and those values are maintained across breakpoints. Naturally, that cache key is out of scope for the subsequent p , so a new value is calculated there. FYI Keep in mind that this is element -based, not selector -based — so long as we're targeting the same element, using the same property, and a value with the same index, the same cache key applies: div { transform: rotate(random(2.5deg, 2.5deg)); } @media (min-width: 55rem) { .rightround { transform: rotate(random(2.5deg, 2.5deg)); } } Different selector, but selector isn't a scoping factor — for the same element, using the same property, with the same random() index, the result is the same rotation. Again, how random() works mechanically might seem a little arcane, but the out-of-the-box behavior gives us predictable results with relatively little code, and "keep the scoping as tight as possible" is an inarguably sensible default for any addition to the web platform. For my part, leaning on defaults means my little sidenotes play out something to the tune of: Looking at you here, 1900s-era JavaScript . :root { --scale-down: 0.925; --scale-up: 1; } .sidenote { align-self: flex-end; animation: movein ease-in-out; animation-timeline: view(); /* … */ transform: scale(var(--scale-down)) rotate(random(2.5deg, 2.5deg)); } @media (min-width: 55rem) { .sidenote { /* … */ transform: scale(var(--scale-down)) rotate(random(2.5deg, 2.5deg)); } } @keyframes movein { 0%, 100% { opacity: 0.5; transform: scale(var(--scale-down)) rotate(random(2.5deg, 2.5deg)); } 50% { opacity: 0.9; transform: scale(var(--scale-up)) rotate(random(2.5deg, 2.5deg)); } } That's a lot of repetition, I know, but remember that there's no assumption of execution order in CSS — any one of these random() calls could be the one that defines their shared cache key. Now, leaning on the default scoping behavior gets the job done for my little margin notes, but doesn't mean we're stuck with the default scoping behavior. So far we've only been passing random() a minimum and maximum value, but that first argument can instead be used to define a random key, with a specific identifier and specific scope — the second argument then defines the minimum value, and so on: .sidenote { transform: rotate(random(--random-rotation auto, -5deg, 5deg, 1deg)); } Used this way, that first argument will allow you to specify two things. The first is a dashed identifier (prefixed with -- ) that will act as the cache key. The second is a keyword that dictates whether that value should be scoped to a property ( property-scoped ) or property and index ( property-index-scoped ), to individual elements ( element-scoped ) or all matching elements identically, to individual elements and property and position ( auto , the default), or a fixed number ( fixed ) which you'd likely only use for debugging purposes. Once we've established a random key and a scope where it applies, we can reuse it in other instances of random() — an explicit means of saying "if a random seed is already available in this scope, use it." Mind the comma placement here, too — the dashed identifier and scope keyword make up one argument. I may or may not have tripped over rotate( random( --random-rotation, auto, 0px, 10px ) a few times myself. Let's walk through our scoping options one at a time: auto In the example above, the --random-rotation identifier I specified just ends up serving as a human-readable representation of the cache key — by specifying auto for the scope, I'm still just leaning on the default per-element property and index scoping. :root { --scale-down: 0.925; --scale-up: 1; } .sidenote { align-self: flex-end; animation: movein ease-in-out; animation-timeline: view(); /* … */ transform: scale(var(--scale-down)) rotate(random(--sidenote-rotation auto, 2.5deg, 2.5deg)); } @media (min-width: 55rem) { .sidenote { /* … */ transform: scale(var(--scale-down)) rotate(random(--sidenote-rotation auto, 2.5deg, 2.5deg)); } } @keyframes movein { 0%, 100% { opacity: 0.5; transform: scale(var(--scale-down)) rotate(random(--sidenote-rotation auto, 2.5deg, 2.5deg)); } 50% { opacity: 0.9; transform: scale(var(--scale-up)) rotate(random(--sidenote-rotation auto, 2.5deg, 2.5deg)); } } It adds a little more noise to an isolated case like this one, but I certainly wouldn't mind having a human-readable label for the availability of a given cache key if we assume a couple thousand lines of real-world CSS between these instances of random() . FYI Despite sharing a shape, this identifier is very different from using random() in conjunction with a custom property. In this case, that property will still represent a call to the random() function itself , not the result of that function's evaluation: :root { --random-margin: random(0px, 10px); } div { margin-block-start: var(--random-margin); } p { margin-block-start: var(--random-margin); } --random-size won't represent the results of calling random( 0px, 10px ); , the way const randomSize = ${ Math.floor(Math.random() * 10 )px would — it represents a fresh call to random( 0px, 10px ) every time it's used. My JavaScript-addled brain recoils in horror. Again though, the addition of a manually-specified cache key doesn't gain us anything over using a generated cache key apart from a human-readable label for what are expected to be shared random() results, and specifying auto will result in the same scoping rules. What specifying a cache key does gain us is the ability to change the scope where that key will be available: property-scoped The invisibility of default/ auto scoping has the potential for confusion once we start adding a little real-world complexity, particularly when it comes to the "index" part of the equation. Given the following, we might expect all these calls to make use of the same random key, same seed, and same rendered result: div { margin-block: random(1rem, 5rem); } @media (min-width: 55rem) { div { margin-block: random(1rem, 5rem) random(1rem, 5rem); } } Here, we're targeting the same element inside and outside the media query and we're using the same property, but the cache key generated by the first call to random() is scoped to the first random value of the margin-block declaration applied to each div — even though we might expect these declarations to give us the same rendered result, the declaration using the start and end shorthand will have an identical margin-block-start , but generate a new random value for the margin-block-end . If we wanted these declarations to be functionally equivalent, we need something a little outside of the default scoping rules. If we instead specify property-scoped to say that the random key should be scoped to just the property — not the index — we can reuse that calculated value as both values in the margin-block shorthand: div { margin-block: random(--random-margin property-scoped, 1rem, 5rem); } @media (min-width: 55rem) { div { margin-block: random(--random-margin property-scoped, 1rem, 5rem) random(--random-margin property-scoped, 1rem, 5rem); } } Now the same value will be used for all three values. We don't have to specify an identifier for the cache key. The previous snippet is functionally identical to: div { margin-block: random(property-scoped, 1rem, 5rem); } /* … */ @media (min-width: 55rem) { div { margin-block: random(property-scoped, 1rem, 5rem) random(property-scoped, 1rem, 5rem); } } Same result, but again: given a couple thousand lines of CSS between these statements, I'd just as soon know what random seed is meant to be associated with which declarations at-a-glance. There's a catch here, though: by explicitly specifying property-scope , we've broadened the scope to only be limited by property — the cache key is no longer scoped to individual elements. Instead, any matching elements will be able to share a single cache key. If we were to only specify property-scope , like so: .sidenote { transform: rotate(random(--random-key property-scoped, -2.5deg, 2.5deg)); } The resulting value will be shared by all elements matching our selector, across all properties — a result comparable to: .sidenote { transform: rotate(/* Pick a random number between -2.5deg and 2.5deg */); } Good news, though: we can control that too. element-scoped By also adding element-scoped to this first argument, we can specify that the shared base value is scoped to individual elements and scoped to property only, not index: .sidenote { transform: rotate(random(--random-key element-scoped property-scoped, -2.5deg, 2.5deg); } But the same way specifying only property-scoped meant " only scoped to property" and lost that individual-element scoping, we can broaden the scope to "individual elements, any property, any index" by specifying element-scoped alone: div { margin-block: random(element-scoped, 1rem, 5rem); } @media (min-width: 55rem) { div { margin: random(element-scoped, 1rem, 5rem) 2rem; } } Here we're saying that per-element is the only applicable scope for this cache key — instead of the default/ auto behavior of being scoped to individual elements, property, and index, this cache key is only scoped to individual elements. That means any instance of random() using these values in any property that applies to any div on the page can share the same random seed, and will result in the same value: div { margin-block: random(element-scoped, 1rem, 5rem); } @media (min-width: 55rem) { div { margin: random(element-scoped, 1rem, 5rem) 2rem; } div.by-class { padding: random(element-scoped, 1rem, 5rem); } } The resulting seed is scoped to each individual div in the rendered page, so all of these calls to random() will result in the same random value between 1em and 5em — but at higher breakpoints, any div.by-class will use that same value for padding as well. Identifier Only We can, in fact, go one step global-er. Specifying an identifier and omitting a specific scope for that identifier results in the broadest possible scope for a cache key: a random key not specific to property or index, and not scoped to individual elements — a random seed scoped to all elements and properties targeted by that styling . “Global-er.” Professional technical writer, folks; can't stress that enough. In this example, the same random seed will be used to calculate a random value that can be reused for any property and any index, but it won't be recalculated from one div to another, either. Unless otherwise overridden elsewhere, the same random value will be used across every div targeted by these selectors: .sidenote { transform: scale(0.925) rotate(random(--random-key, -2.5deg, 2.5deg)); } The resulting value will be shared by all elements matching our selector, across all properties — a result comparable to: .sidenote { transform: scale(0.925) rotate(/* A random value between -2.5deg and 2.5deg */); } But because we're not scoping this to property or index, that means all of these calls to random() will result in the same value: .sidenote { margin-block-start: random(--random-key, 1rem, 5rem); } @media (min-width: 30rem) { .sidenote { border: solid red; border-width: random(--random-key, 1rem, 5rem) random(--random-key, 1rem, 5rem) 0 0; } } @media (min-width: 50rem) { .sidenote { font-size: random(--random-key, 1rem, 5rem); } } Any property, any index — and because we've left the realm of auto or element-scoped , every .sidenote element will be rendered using the same random value for all of these properties, if and when they apply to the user's browsing context. fixed There's one more random key you can specify, and it's a weird one. Remember back where I said "when random( 0px, 100px ) is called, a random seed between 0 and 1 is generated to perform the calculation of the resulting value - how, given random( 0px, 100px ) and a random seed of .5 , the resulting value would be 50px ?" Well, the keyword fixed will allow you to specify a base value manually , using a number between zero and one — a hard-coded seed: .sidenote { transform: rotate(random(fixed 0.5, -2.5deg, 2.5deg)); /* 0deg */ transform: rotate(random(fixed 0.5, 0deg, 20deg)); /* 10deg */ transform: rotate(random(fixed 0.25, 0deg, 100deg)); /* 25deg */ } As you might have guessed, fixed has a pretty specific use case: it gives you a quick way to try out some of the values that might result from a call to random() without needing to scratch out the entire line and replace it with a static value. You'd never use this in production. Odds are, you'll only reach for fixed when finessing the upper and lower bounds of a call to random() to see how a range of potential results would render — I certainly did, if only to try it out. Granted, trying a few different fixed values on for size was probably overkill for my purposes; realistically, a sense of how a whopping five (5) potential degrees of rotation will play across a few little side notes doesn't require much more than a couple of page-reloads and a little imagination. Still, tinkering with those base values does give you a little glimpse into the mechanics of how random() rolls the dice. “Anything worth doing is worth—” well, you know the rest. As for how those base values are shared between calls to random() , well, that clearly requires a little more imagination.
HeyDesignerDeveloper/Designer Newsread at source
What I’ve learned writing for billions of users
Brand typography at scale, Squircles.
Net NinjaYouTube ChannelsVideoWatch on YouTube
"Anti-Slop" Designs with Impeccable (a Crash Course) #5 - Enable Image Generation
AdactioTop Front-end Bloggersread at source
Going to Amsterdam. brb
SitePointThe Giantsread at source
Retail Merchandising Principles for Web Designers and Developers: Display Design, Ranking Rules and Measurement
null Continue reading Retail Merchandising Principles for Web Designers and Developers: Display Design, Ranking Rules and Measurement on SitePoint .
Flavio CopesMore Front-end Bloggersread at source
How to use Code Mode in Claude Code
Code Mode makes Claude Code write JavaScript that chains its tool calls and runs long jobs in the background. I tried it on a real project.
AbduzeedoMulti Author Blogsread at source
ThreeRT: Real-Time Ray Tracing for three.js
ThreeRT by MeshyAI brings real-time ray tracing at 60 fps to a three.js-style API, trading baked shadow maps for live bounce light. Dragging the comparison sliders on ThreeRT makes the gap between ras...
AbduzeedoMulti Author Blogsread at source
Meshfont: Browser Font Editor With AI Agent Support
Meshfont is a free browser font editor that lets you sculpt open-licensed typefaces with Bézier handles, warp tools, and MCP AI agents. Open the Meshfont homepage and the interface behaves like a live...
Chris HawkesYouTube ChannelsVideoWatch on YouTube
ChatGPT Astra 6.2 Can Build Games Now? My First Impressions
Brad FrostTop Front-end Bloggers3 min read
Skills to pay the bills...and address your design system's check engine light
We like to make things and help people. That's why I've become fascinated by AI agent skills; I see them as exciting new ways to help people and make things better. So allow me (...and The Beastie Boys, our Eddie design system, and Opus 5.5) to introduce bradfrost/skills ! These…
Frontend FocusMulti Author Blogsread at source
What developers think of HTML right now
🚀 Frontend Focus #767 — November 18, 2026 | Read on the web 🗳️ The State of HTML 2026 Results The State of HTML 2026 results are now out covering what developers are using, loving and struggling with, plus how much they use AI . Declarative, element-based features are winners, while form controls remain difficult. Some highlights: details >/ summary > (72.5%) and dialog > (67.8%) are the most used interactivity features, and use of the Popover API has reached 40% now that it works in every major browser. select > and date inputs are the hardest elements to style, and customizable select is the feature most held back by browser support (Firefox is yet to ship it). datalist > usage jumped from 30% to 44%, yet positive sentiment fell from 44% to 34%, with respondents citing styling, accessibility and browser bugs. Native data tables with built-in sorting and filtering topped the wishlist, ahead of tabs, comboboxes and switches. HTML includes came up again. In his overall conclusion , Polypane creator Kilian Valkhof sees the frustration shifting from browsers doing things differently to browsers simply not having caught up yet, with mobile OSes a particular sore spot. He ends: "Our industry might be in turmoil, but I think our foundation is in good shape." Devographics A Form Platform That Fits Your App — Design complex forms visually and render them in React, Angular, or Vue. Keep full control over your backend and data. Create custom themes or use style adapters, extract form responses from PDFs and images with AI, and generate or fill existing PDF forms. SurveyJS sponsor 🤖 Top 10 Things AI Gets Wrong in Web Development — The Chrome team tested frontier coding agents and found they pass only about 50% of web best-practice checks unguided, but ~90% with Modern Web Guidance installed. The areas they get wrong include accessibility, performance and security. Philip Walton (Google) Introducing the Cross-Origin Storage API — A new API proposal from the Chrome team to enable sites to share large assets (like AI models, fonts, common libraries, etc.) meaning end users would save bandwidth by only having to download them once. Thomas Steiner ⚡️ IN BRIEF 🔦 jQuery 4.1 and 3.8 are out . 3.8 is the last planned feature release of the 3.x line, which now gets critical fixes only. 📑 Or perhaps you don't need jQuery at all? The long-standing ' You Don't Need jQuery ' guide has had a major update, swapping IE fallbacks for modern one-liners. 🌐 Chrome 158 is now stable , with the install element, media state pseudo-classes like :playing and :paused , and the start of XSLT's staged removal. Plus there's a look at what's new in the DevTools . ⛓️💥 A cautionary tale about using link shorteners: some old Bitly links were recently hijacked , repurposing where they sent people. 🌅 As we mentioned last month, Arc is going away on December 22, so Chris Coyier rounds up the browsers worth trying instead . 📙 Articles, Opinions & Tutorials Charts in HTML and CSS — A neat gallery of column and bar charts, heatmaps, donuts, line charts and more, built from just HTML and CSS (no JavaScript or SVGs). It's all built upon semantic markup, so if you strip away the stylesheet, they remain readable tables or lists. There's also an agent skill. Keith Cirkel Charts That Do Analytics? Yes, With One Script — Give your users forecasts and anomaly detection in the chart itself. Orbit for Highcharts, free for 60 days . Highcharts sponsor The CSS caret-* Properties and Custom Caret Accessibility — A thorough look at the newer caret-shape and caret-animation properties alongside caret-color for styling the text cursor. Covers caret browsing, WCAG rules, and how author styles can trump users' caret preferences. Sara Soueidan What Safari on Apple HomeView Means for Your Site — Safari now runs on Apple's square, 7-inch, voice-driven display. Most sites 'just work' but Jen flags some assumptions that break, like a shorter viewport than usual, an iOS user agent on a non-iPhone, and voice users who need labeled controls. Jen Simmons (WebKit) PropFLIP: Because It Flips with Props — Adam takes four @property custom properties and uses them, along with a transition, to create a neat flip effect. A sprinkling of JS helps bring it all together. Adam Argyle Giving AI Agents a Better Way to Debug CSS Amit Merchant Building an atproto Link Aggregator Johanna Larsson 🧰 Tools, Code & Resources Allo: Your Friendly Neighborhood Font — A really nice, free, open source typeface with variable weights and roundness options, automatic optical sizing, plenty of alternates, and much more. The site does an excellent job of showing it all off. Repo here . Josh Puckett 📊 Who Shipped First? Chromium vs Gecko vs WebKit — A look at 'which browser engine got there first' for a huge range of Web platform features. Patrick used the web-features data for this and Chromium/Chrome, perhaps unsurprisingly, has a clear lead in introducing new features. Patrick Brosset Your Chart Renders Fast. The Query Behind It Doesn’t — Tiger Cloud keeps dashboard queries fast as data grows, and it’s still Postgres underneath. $1000 credit to start . Tiger Data (creators of TimescaleDB) sponsor 🐞 BugShot: Chromium Extension for Streamlined Bug Reporting — Adds a side panel for turning browser bugs into a report that includes captures, annotations, recordings, and logs. It can then submit reports directly to Jira, GitHub, Linear, Notion, and more. SinhyeokKang Astrobook: A Minimal Storybook Alternative — An alternative to the popular Storybook UI component playground that supports React, Vue, Preact, Svelte, Solid, Lit, and Astro. The demo site includes multiple framework examples. Ocavue Aura: Ambient Gradients Built from Layered CSS Blend Modes — 200+ customizable gradients that offer a soft, atmospheric look that feels 'like light' . Click any gradient to preview it live, browse sub-categories (mesh, nebula, lattice, glass, etc.), and export as PNG, SVG, CSS, Tailwind, etc. GitHub repo . Cristian Olivera 📰 Classifieds ⚡️ Add lightning-fast 1D/2D barcode scanning to your web app with STRICH . On-device processing, free trial and demo! 📱 No Mac needed. Expo Simulators gives your coding agent a cloud iOS Simulator to test its own work, on Linux or Windows. 🧾 Generating invoices or reports from JSON? Foxit compares 10 PDF generator APIs on templates, HTML rendering and how each one bills. 🥽 ...and finally WebKit Previews Spatial CSS — An early look at arranging 3D model > objects on the web with plain CSS with which you can group them in a shared space, snap them together, and tweak the lighting. A JavaScript call can even pop the scene out into the room around you. Safari on visionOS only, behind a flag ( remember Vision Pro? ). Brandel Zachernuk (WebKit)
AbduzeedoMulti Author Blogsread at source
XK Studio: Timeline Navigation Web Design by Bureau Cool
Bureau Cool’s web design for motion practice XK Studio pairs a bottom filmstrip timeline and playtime ticks with scroll video switching. Along the bottom edge of XK Studio’s homepage, Bureau Cool line...
Heroku BlogCompany/Startup Blogs5 min read
Introducing Snapshot Migration to Heroku Postgres Advanced
When we announced Heroku Postgres Advanced in October, migration tooling for Postgres Classic databases was the first item on our roadmap. The first part of that tooling is available today: heroku data:pg:migrate. heroku data:pg:migrate is a guided, interactive Heroku CLI workflow that moves a Postgres Classic tier database to Heroku Postgres Advanced. You don’t write […] The post Introducing Snapshot Migration to Heroku Postgres Advanced appeared first on Heroku .
AbduzeedoMulti Author Blogsread at source
Estúdio Caxa Unveils Outra Coisa Brand Identity
Estúdio Caxa builds the Outra Coisa brand identity from rum, mate and pineapple, with loose drawings, loud color and nonsense. Outra Coisa is a Brazilian mixed alcoholic drink, rum with mate, pineappl...
AbduzeedoMulti Author Blogsread at source
Mother Design Reimagines Modern Wellness Branding for Keen
Mother Design reframes 25-year psychic platform Keen through warm wellness branding, circular portals, and María Jesús Contreras’s art. Two symmetrical curved Es lock between upright K and N stems at ...
Next.js BlogLibraries, Frameworks, etc.read at source
How we're using AI to make Next.js more secure
Why you're seeing more Next.js security advisories, and what we're doing about it.
Microsoft Edge BlogBrowsers, engines, etc.13 min read
Edge for Business becomes the most used enterprise browser and unveils Ignite 2026 innovations
https://www.youtube.com/watch?v=eK7msluMltY Summary: Edge for Business is the most used enterprise browser in the world. At Microsoft Ignite 2026, we're introducing new ways for users and agents to get more done. Deeper integrat The post Edge for Business becomes the most used enterprise browser and unveils Ignite 2026 innovations appeared first on Microsoft Edge Blog .
Flavio CopesMore Front-end Bloggersread at source
How to use GitHub Copilot CLI: a complete tutorial
Learn GitHub Copilot CLI with a real coding task: install, sign in, control permissions, review changes, run tests, manage context, and add skills, Ponytail and MCP tools.
Flavio CopesMore Front-end Bloggersread at source
How to use GPT-6.2 Astra and Sol in Codex and the API
Choose between GPT-6.2 Astra and Sol, compare a real code review, and preserve conversation history with the OpenAI Responses API.
AbduzeedoMulti Author Blogsread at source
One Month of MaPC: 32 Versions Later
One month after launch, MaPC has shipped 32 versions, added three stores, and run The Witcher 3 and Hogwarts Legacy on Mac. MaPC launched in mid-October as a free native Mac app that runs Windows game...
Speckyboy Design MagazineDeveloper/Designer News8 min read
The Best WordPress Hosting Black Friday Deals in 2026
Black Friday brings huge savings on WordPress hosting. See which hosts offer real value, solid performance, and lasting discounts this year. The post The Best WordPress Hosting Black Friday Deals in 2026 appeared first on Speckyboy Design Magazine .
Google for DevelopersYouTube ChannelsVideoWatch on YouTube
EmbeddingGemma 2: How natively multimodal embeddings work
HeyDesignerDeveloper/Designer Newsread at source
AI skills for building better interfaces
Designing with HTML, Design Zeitgeist, Building interfaces that understand what we want to do, Design is a search problem, and more.
AbduzeedoMulti Author Blogsread at source
Inside the Craft of the Snapple Rebrand 2026 by Deutsch Design
Deutsch Design restores Snapple's 90s racetrack logo in the Snapple rebrand 2026, rebuilt with custom letterforms and flavor-first packaging. The change starts with the mark itself. The navy serif Sna...
Go Make ThingsMulti Author Blogs1 min read
Wasting Time
I saw this on one of the social sites the other day, but I can’t remember which (or who shared it)… “Wasting time” might be one of the strangest accusations we’ve ever invented. Apparently you can waste 2:00 p.m. by sitting under a tree doing nothing. The afternoon was going to pass either way. The Earth was going to rotate either way. But because you didn’t convert those hours into money, errands or improvement, we decided the time itself was wasted.
The Mozilla BlogBrowsers, engines, etc.2 min read
Has Microsoft wronged you? Firefox opens a complaints line at Microsoft Ignite
This week, Firefox is taking over the streets around the Moscone Center in San Francisco, where Microsoft is holding Ignite, its biggest conference of the year. While they talk about what’s next for Windows, Firefox is taking over the surrounding streets to remind them of what they haven’t fixed: Microsoft hasn’t changed the concerning design […] The post Has Microsoft wronged you? Firefox opens a complaints line at Microsoft Ignite appeared first on The Mozilla Blog .
AdactioTop Front-end Bloggersread at source
Reading Eat the Ones You Love by Sarah Maria Griffin.
W3C NewsBrowsers, engines, etc.1 min read
W3C opens Technical Architecture Group (TAG) election
The W3C Advisory Committee, having nominated nine individuals, is invited today to vote until 15 December 2026 to fill five seats in the W3C TAG election.
Smashing MagazineThe Giants10 min read
Meet AI 2027 Conference (Dec 1)
Roll up your sleeves! Meet shiny new [AI 2027 Conference](https://smashingconf.com/ai-2027-conference), a friendly online conference on AI-ready design systems, AI + Figma and AI design patterns. What to expect in 2027 and where teams are getting AI right. [Jump to tickets.](https://smashingconf.com/ai-2027-conference/registration)
Darek KayMore Front-end Bloggers1 min read
#0200
Red and purple firework next to a tower. Green and yellow smoke below the tower. The top of the tower is illuminated.
AdactioTop Front-end Bloggersread at source
The nature of my job has completely changed · Rach Smith’s notes & nuggets
My almost life long, enduring special interest has been writing code to create things. I like to think I’m pretty good at it. Instead of doing that, I’m writing requirements, answering questions, reading and reviewing lines and lines (and lines), and QA testing the results. There’s no flow to be found in this approach. Instead of my workday flying by, I’ll work 4 hours and it will feel like 6. I’m exhausted from parsing so much information. I also can’t go back. adactio.com/links/22837
AdactioTop Front-end Bloggersread at source
Computing with CSS Layout
This document tries to answer one question: how much can CSS compute on its own? A heckuva lot, as it turns out! I don’t understand all of this, but I’m very impressed. adactio.com/links/22836
Flavio CopesMore Front-end Bloggersread at source
A deep dive into ChatGPT Sites
ChatGPT Sites turns a prompt into a hosted website or small web app. How to use it step by step, what runs under the hood, what hosting will cost, and its limits.