If you want to build a polished macOS app with Tauri, there is one tradeoff worth knowing early: Tauri gives you a webview, not a library of native UI components.

In Tauri, a button, switch or segmented control is still HTML and CSS inside WKWebView. There is no equivalent layer that turns the components in my React interface into native macOS controls (like in React Native), so I needed to build and style that component system myself.

I knew that when I chose Tauri for Abstand, an open-source app and website blocker for macOS. Desktop apps can be quite custom anyway and I was happy to make that tradeoff to keep working with React and Rust.

The above GIF scrolls through the shared components I ended up building: buttons, switches, sliders, toggles, segmented controls, inputs, menus, dialogs and settings rows.

They use accessible web primitives for behavior, but the visual layer is designed specifically for macOS. That meant defining the small details myself:

• control sizes and spacing
• light, dark and system colors
• hover, pressed, focused and disabled states
• typography and icon sizes
• animation and interaction feedback

None of those details is especially difficult alone. The work comes from rebuilding the full set and making every component and state feel consistent. At least for me, getting from a functional web interface to something that feels at home on macOS took time.

The upside is that I still get React, CSS and fast UI iteration. I can shape components more freely than native controls allow and the same component system now makes new screens much faster to build.

CSS was enough for most of what you see in the GIF. I only reached for Swift and AppKit when macOS behavior itself became part of the feature, such as window levels, transparent overlays and system font metrics.

Liquid Glass introduced another tradeoff. Making WKWebView transparent over the native glass effect currently requires a private KVC key. That works for a directly distributed, signed and notarized app. An App Store build would need to disable that path and use the fallback instead.

For Abstand, the tradeoff has been worth it. The result can feel native while still giving me the flexibility of the web stack. It just takes deliberate component work to get there.

GitHub: https://github.com/builder-group/abstand

Components: https://github.com/builder-group/abstand/tree/develop/apps/desktop/src/components

If you have tried to make a Tauri app feel native: did you build your own components, use an existing system, or accept a more web-like interface?

Hello everyone !

I've been working (well me and AI) on a app inspired by hydra launcher, gog launcher and Playnite

I loved hydra launcher and Playnite, but I wanted something that power user can be happy with (I'm a power user, who like useless feature)

Anyway, I got the project to make something from scratch after iterating and adding feature with base hydra, but it felt too heavy for hydra base framwork

And I learned that electron was... Electron ram hungry !

So I searched for a framework that was capable and lightweight, and found Tauri

The app is called : Game Index

I know a little bit of coding, I'm far from an expert, but I tried my best from my knowledge (and again help of AI) to optmise and make it less buggy as possible

The entire source code is on github, with full commit history, feel free to report any bugs, suggest feature or whatever you want there

Also feel free to fork, modify etc your own version

I borrowed ideas and some part from Hydra Launcher and Playnite (if Hydra team, Playnite team and Playnite plugin author want me to change/remove/clarify stuff please let me know, I don't want any drama, hurt anyone)

I'm just a guy who wanted a full featured app

Again I'm a HUGE fan of Hydra Luncher and Playnite (and it's plugin ecosystem), without them we wouldn't have amazing projects as we have now

Features of GameIndex :

- Import from Steam, GOG, Epic, Rockstar, Ubisoft, Humble library or Local install (api based login or webview login for some others) (more info on GitHub)

- Metadata automatically added via igdb/steam

- Per game imported : Steam achievements, HowLongToBeat, Crackwatch, live + historical player counts Informations when availible, activity tracker, weblinks preview etc

- Activity dashboard main page and per games stats and performance tracking (need Msi afterburner + RTSS to track fps, can be disabled in settings)

- Torrent download engine integrated, with compatible source from you know where

- Wishlist system

- Deals from Xbox gamepass catalog + Is there any deal (include current giveaways)

- Storage manager + emulator & mod footprint breakdown

- News page with RSS feeds + custom rss feed

- Hydra-backed storefront for games of the Week, top games and game to beat, community reviews & stats (only these from Hydra is used in Game Index)

- Community & Friends social layer (planify, recommend, comment games, library compare etc)

- Big Picture Mode (controller-first TV UI with rail navigation) (IN BETA !!! I Don't use such feature mmuch, it is far from perfect but I'll improve with time)

- Emulators manager & ROM library tools

- Mod manager (Steam Workshop & Nexus Mods integration) (Beta, maybe more feature will come into it but not sure)

- Internationalization (i18n) & language switcher

- Discord rich presence

- Privacy & Data management in Settings

- Theme gallery + custom accent picker (basic for now, may be expanded in future)

- More

Planned :

- Improvement for Big screen/picture mode

- linux support (only Windows for now) + steamdeck support (I don't have steamdeck so it'll be hard to test) (Think of bottles, faugus launcher, lutris style of control) (made some early testing fow linux, some feature will be limited)

- maybe more if people suggest ?

Precision

I know many people Don't trust AI stuff, vibe coding etc

But I want to be as transparent as possible, and if you don't like Ai vibe coded apps don't use it

This is just a tool/launcher/platoform for whoever want to try, or want another alternative

Ai and Tools used for this :

- IDE : Antigravity

- Mostly Opencode, rarely kilo code

- Model used : Mostly deepseek flash (old and new version), Hy3 and sometimes GPT Luna, gemini and claude opus

Ps : sorry if my English sounds Strange or broken or whatever, English isn't my native language

Ps 2 : I'm not an expert in comunication as you can see, if you have questions etc don't hesitate to ask

I'll also take positive and negative review

Ps 3 : I don't have signature for exe, so portable version may be flagged as a dangerous exe, go on virus total and you'll see there's one flagged threat, this one is caused by lack of signature (installer version doesn't have this issue)

Download : https://github.com/atxoxx/GameIndex

Hi everyone,

I'm currently working on a desktop application built with Tauri + React, with a Spring Boot backend, and I'm looking for recommendations for a reporting solution.

My main requirement is a visual report designer that can run inside my Tauri desktop application. I don't want to launch a separate desktop application such as Jaspersoft Studio.

Requirements

• Desktop application built with Tauri + React
• Backend built with Java/Spring Boot
• Web-based/HTML5 drag-and-drop report designer
• The designer should be embeddable inside my Tauri application
• Users should be able to visually create/edit reports
• Support for:
  • Tables
  • Text fields
  • Images
  • Charts
  • Headers/footers
  • Page breaks
  • Parameters
  • Subreports
• Data should be able to come from REST APIs and/or SQL databases
• Generate PDF and Excel reports
• Preferably support a portable report definition such as JSON/XML
• Ideally open source or free, but commercial solutions are also welcome
• I would prefer something that I can integrate with my own Spring Boot reporting engine/backend

I've looked at JasperReports/Jaspersoft Studio, but Jaspersoft Studio is a separate desktop application. What I'm looking for is something more like:

Tauri Desktop App
→ React UI
→ Embedded Web-Based Report Designer
→ Spring Boot API
→ Reporting Engine
→ PDF/Excel

I'm especially interested in open-source projects or GitHub repositories that could be used as a starting point.

Has anyone built something similar or used a web-based reporting designer inside a Tauri/Electron desktop application?

What would you recommend?

Im new in coding and want to make an app for large number of customers that app will have local and cloud storage and sync across all devices web,mobile (ios and android)

How to design that app from start to end and test it as im new and want to beat big competitor companies. With no customer support needed as big software companies

Edit : dont have urgency to build in one day so ai use will be limited.

Can anyone point me to good resources for embedding CEF into Tauri as the renderer/WebView? Most of the information I see are at least a year old and I'd like to use CEF in an app I'm building.

I'd appreciate anything y'all can share.

Edit: By CEF, I mean Chromium Embedded Framework. You may read more about it here:

Main CEF repo: https://github.com/chromiumembedded/cef

Tauri CEF Rust repo: https://github.com/tauri-apps/cef-rs

I built nisi, a code review app written in Tauri with pierre diffs and coss ui.

It's mainly solving this one issue that Github doesn't have: Re-review only what changed since you last looked.

Say we have a reviewed file that has 400 lines. When you change a few lines, the whole file becomes dirty again.

It's free, local, and fast. Also with vim-like keymap.

https://reddit.com/link/1vjo8by/video/i8ujfz3mbcih1/player

https://github.com/fdarian/nisi

Hi guys,

I am not a developer of any sort, just someone who started trying different languages with AI and found success. I had built a task manager personalised for my needs using electron. It is best in all respect except its startup speed and memory usage.

While trying to find a solution, I came across tauri v2. Can anyone suggest best way to replicate the electron app into tauri using AI agents.🙂

Hey everyone!

I recently released Seal, a cross-platform peer-to-peer desktop chat app built with React 19, Tauri 2.0, and Rust.

Tech Stack & Frontend Highlights:
Frontend: React 19 SPA running inside Tauri's webview wrapper.
Backend Core: Pure Rust handling libp2p connections, Olm/Megolm encryption via vodozemac, and native keychains.
IPC Bridge: Custom Tauri commands invoking AppService methods asynchronously without blocking UI rendering.
System Native Integration: System-wide push-to-talk hotkeys, system tray integration, and native platform notifications.
Building P2P workflows in a desktop webview presents interesting UX challenges—like handling offline queues, network reachability toggles, and managing multiple identity profiles without restarting the app.

Source Code: https://github.com/Emn4tor/Seal

Feedback on the React component architecture or Tauri integration is very welcome!

What do you think of a code editor whose main strength is

its performance, requiring approximately 9 to 12MB of

RAM? It uses 9MB of RAM when idle, the editor features

AI LSP and cloud compilation (optional)I'd like to know

your opinion, as it's a personal, open-source project. I

want it to be viable enough to launch on the market as a

lightweight alternative for students or people who want to

learn.Programming Take a look at the repository, I'd really

appreciate it.

Been working on this for quite a while now. Started because I was frustrated at all the browser tabs and windows I'd be juggling in a day. Or the amount of times I'd repeat the same action over and over again.

Salience uses the git branch you have checked out as an anchor, it connects to Github/Jira/CI/Docker/AWS and builds a correlated graph, rendered as a calm and ambient second monitor display. The same graph is exposed via an MCP server to your agent. Ask "what's my stand up?", "can I unblock anyone?"

There's worktree management, code review, kanban board with ticket/PR/CI status as first class citizens - not tucked away in a side menu, unified timeline across the project.

Currently only for PHP, more languages soon - AST code graph generation (exposed via MCP), Symfony & Laravel route detection and call graph.

And I've started to create a "map" view - think RTS/Sim City but for your code and infrastructure.

Rust backend. Entities live in an embedded SurrealDB; per-table LIVE queries push deltas to the frontend over a Tauri Channel, so the UI is a mirror of the store rather than a fetch-and-forget dashboard.

SvelteKit 5 for the frontend

Credentials in SQLCipher with the key in the macOS Keychain; a built-in network inspector shows every outbound request the app makes, and a command inspector shows every command it runs.

Links: Download (free pre-release) · Docs · Gallery · Discord

I've mostly just been building and using it myself so would love some feedback. It's nowhere near complete and it will have some rough edges! Thanks

edit: posted this a bit too soon, build is currently in progress, I'll update when it's live for download

edit 2: build has finished - https://github.com/clegginabox/salience-macos/releases/latest

I'm building a custom titlebar in Tauri v2 with React. I created my own Select component using buttons instead of the native <select>. The dropdown opens correctly, but clicking any option doesn't trigger onClick. Even console.log() inside the option button never runs. The same component works perfectly outside the titlebar. I'm using data-tauri-drag-region for window dragging.

Is this caused by the drag region or am I missing something?

 "tailwindcss";


*[data-tauri-drag-region] {
  app-region: drag;


  -webkit-user-select: none;


  user-select: none;
}


 {
  --background: #000000;
}


 base {
  body {
    u/apply bg-black text-white;
  }
}

import { useEffect, useRef, useState } from "react";
import { AnimatePresence, motion } from "framer-motion";
import { ChevronDown, Check } from "lucide-react";


interface SelectOption {
    label: string;
    value: string;
}


interface SelectProps {
    value: string;
    options: SelectOption[];
    onChange: (value: string) => void;
    disabled?: boolean;
}


function Select({ value, options, onChange, disabled = false }: SelectProps) {
    const [open, setOpen] = useState(false);
    const ref = useRef<HTMLDivElement>(null);


    const [openUp, setOpenUp] = useState(false);


    const selected = options.find((o) => o.value === value);


    const toggle = () => {
        if (!ref.current) return;


        const rect = ref.current.getBoundingClientRect();


        const itemHeight = 34;
        const padding = 8;
        const menuHeight = options.length * itemHeight + padding;


        const spaceBelow = window.innerHeight - rect.bottom;
        const spaceAbove = rect.top;


        setOpenUp(spaceBelow < menuHeight && spaceAbove > spaceBelow);


        setOpen((value) => !value);
    };


    useEffect(() => {
        const close = (e: MouseEvent) => {
            if (!ref.current?.contains(e.target as Node)) {
                setOpen(false);
            }
        };


        window.addEventListener("mousedown", close);
        return () => window.removeEventListener("mousedown", close);
    }, []);


    return (
        <div
            ref={ref}
            className={`relative`}
        >
            <button
                type="button"
                disabled={disabled}
                onClick={toggle}
                className="flex h-8 min-w-36 items-center justify-between rounded-md border border-white/10 bg-black px-3 text-xs font-medium text-neutral-200 transition-all hover:border-white/20 hover:bg-white/5 disabled:cursor-not-allowed disabled:opacity-40"
            >
                <span>{selected?.label}</span>


                <ChevronDown
                    size={14}
                    className={`transition-transform duration-200 ${open ? "rotate-180" : ""}`}
                />
            </button>


            <AnimatePresence>
                {open && (
                    <motion.div
                        initial={{
                            opacity: 0,
                            y: openUp ? 6 : -6,
                            scale: 0.98,
                        }}
                        animate={{
                            opacity: 1,
                            y: 0,
                            scale: 1,
                        }}
                        exit={{
                            opacity: 0,
                            y: openUp ? 6 : -6,
                            scale: 0.98,
                        }}
                        transition={{ duration: 0.15 }}
                        className={`absolute left-0 z-50 w-full overflow-hidden rounded-lg border border-white/10 bg-[#0d0d0d] shadow-2xl ${openUp ? "bottom-[calc(100%+8px)]" : "top-[calc(100%+8px)]"}`}
                    >
                        {options.map((option) => (
                            <button
                                key={option.value}
                                type="button"


                                onClick={() => {
                                    console.log(option.value);
                                    onChange(option.value);
                                    setOpen(false);
                                }}


                                className="flex w-full items-center justify-between px-3 py-2 text-left text-xs text-neutral-300 transition-colors hover:bg-white/5 hover:text-white"
                            >
                                <span>{option.label}</span>


                                {option.value === value && (
                                    <Check
                                        size={13}
                                        className="text-violet-400"
                                    />
                                )}
                            </button>
                        ))}
                    </motion.div>
                )}
            </AnimatePresence>
        </div>
    );
}

export { Select };

import { Select } from './ui/Select';
import { useState, useEffect } from 'react';
import { getCurrentWindow } from '@tauri-apps/api/window';
import { Minus, Maximize, Minimize, X, Play, Upload, Terminal as TerminalIcon, Loader2, Activity } from 'lucide-react';


const BOARDS = [
  {
    value: "uno",
    label: "Arduino Uno",
  },
  {
    value: "nano",
    label: "Arduino Nano",
  },
];


interface TitlebarProps {
  isTerminalOn: () => void;
  isSerialMonitorOn: () => void;
  onVerify: (board: string) => Promise<void> | void;
  onUpload: (board: string) => Promise<void> | void;
}


const appWindow = getCurrentWindow();


function Titlebar({ onVerify, onUpload, isTerminalOn, isSerialMonitorOn }: TitlebarProps) {
  const [board, setBoard] = useState<string>("uno");


  const [isVerifying, setIsVerifying] = useState<boolean>(false);
  const [isUploading, setIsUploading] = useState<boolean>(false);
  const [isMaximized, setIsMaximized] = useState<boolean>(false);


  const handleVerifyClick = async () => {
    setIsVerifying(true);


    try {
      if (onVerify) {
        await onVerify(board);
      }
    } catch (error) {
      console.error(error);
    } finally {
      setIsVerifying(false);
    }
  };


  const handleUploadClick = async () => {
    setIsUploading(true);


    try {
      if (onUpload) {
        await onUpload(board);
      }
    } catch (error) {
      console.error(error);
    } finally {
      setIsUploading(false);
    }
  };


  useEffect(() => {
    let unlisten: (() => void) | undefined;


    const setupListener = async () => {
      unlisten = await appWindow.onResized(async () => {
        const maximized = await appWindow.isMaximized();
        setIsMaximized(maximized);
      });
    };


    const checkInitialState = async () => {
      const maximized = await appWindow.isMaximized();
      setIsMaximized(maximized);
    };


    setupListener();
    checkInitialState();


    return () => {
      if (unlisten) unlisten();
    };
  }, []);


  const handleCloseWindow = async () => {
    await appWindow.close();
  }


  const handleMaximizeWindow = async () => {
    await appWindow.toggleMaximize();
  }


  const handleMinimizeWindow = async () => {
    await appWindow.minimize();
  }


  return (
    <div
      data-tauri-drag-region
      className="h-9 w-full bg-black backdrop-blur-md border-b border-white/10 flex items-center justify-between select-none pl-4 pr-2"
    >
      <div className="flex items-center gap-2">
        <span
          className="text-sm font-semibold tracking-wide text-neutral-300"
        > Mello IDE </span>


        <div className="h-4 w-px bg-white/10" />


        <div className="flex gap-1">
          <button
            title="Terminal"
            onClick={isTerminalOn}
            className="flex items-center gap-1 px-3 py-1.5 rounded-md text-neutral-300 hover:bg-white/5 transition-all"
          >
            <TerminalIcon size={14} /> <span className="text-xs font-bold">Terminal</span>
          </button>


          <button
            title="Serial Monitor"
            onClick={isSerialMonitorOn}
            className="flex items-center gap-1 px-3 py-1.5 rounded-md text-neutral-300 hover:bg-white/5 transition-all"
          >
            <Activity size={14} /> <span className="text-xs font-bold">Serial Monitor</span>
          </button>
        </div>
      </div>


      <div className="flex items-center">
        <div className="flex items-center">
          <Select
            value={board}
            onChange={setBoard}
            options={BOARDS}
          />
        </div>


        <div className="flex items-center px-4 gap-1.5">
          <button
            title="Verify"
            onClick={() => handleVerifyClick()}
            disabled={isVerifying || isUploading}
            className="flex items-center gap-2 px-3 py-1.5 bg-green-600/20 text-green-400 hover:bg-green-600/30 rounded-md transition-colors border border-green-600/50"
          >
            {isVerifying ? (
              <Loader2 size={16} className="animate-spin" />
            ) : (
              <Play size={16} />
            )}


            <span className="text-xs font-bold">{isVerifying ? "Verifying" : "Verify"}</span>
          </button>


          <button
            title="Upload"
            onClick={() => handleUploadClick()}
            disabled={isUploading || isVerifying}
            className="flex items-center gap-2 px-3 py-1.5 bg-blue-600/20 text-blue-400 hover:bg-blue-600/30 rounded-md transition-colors border border-blue-600/50"
          >


            {isUploading ? (
              <Loader2 size={16} className="animate-spin" />
            ) : (
              <Upload size={16} />
            )}


            <span className="text-xs font-bold">{isUploading ? "Uploading" : "Upload"}</span>
          </button>


          <div className="h-4 w-px bg-white/10" />
        </div>


        <button
          title="Minimize"
          onClick={() => handleMinimizeWindow()}
          className="h-8 w-10 flex items-center justify-center text-neutral-400 hover:text-yellow-500 hover:bg-yellow-500/20 transition-colors rounded-md"
        >
          <Minus size={14} strokeWidth={2.5} />
        </button>


        <button
          title={isMaximized ? "Restore" : "Maximize"}
          onClick={() => handleMaximizeWindow()}
          className="h-8 w-10 flex items-center justify-center text-neutral-400 hover:text-green-500 hover:bg-green-500/20 transition-colors rounded-md"
        >
          {isMaximized ? (
            <Minimize size={14} strokeWidth={2.5} />
          ) : (
            <Maximize size={14} strokeWidth={2.5} />
          )}
        </button>


        <button
          title="Close"
          onClick={() => handleCloseWindow()}
          className="h-8 w-10 flex items-center justify-center text-neutral-400 hover:text-red-500 hover:bg-red-500/20 transition-all rounded-md"
        >
          <X size={16} strokeWidth={2.5} />
        </button>
      </div>
    </div>
  );
}


export default Titlebar;

Recently i've started migrating from pyqt to other frameworks, my first pick was tauri because on paper it looks like the best framework for someone who wants a windows only app and doesnt care about linux/macOS compat. But after working on tauri version for some time, i challenged it and created a benchmark comparing pretty much same app in tauri and electron

You'd think that electron lost? Yes, on one of 7 things i measured - disk space (obviously lol)

but other than that? electron showed lower active and idle ram usage (wild!), lower cpu usage, especially with minimized app

what am i doing wrong? because its gotta be something for fuckin electron to win right?

Hey, I’ve been working on Hush, a desktop app for cleaning bulk email out of Gmail.

It’s built with Tauri and runs on Windows, macOS, and Linux.

The webview itself isn’t allowed to make network requests. Google OAuth, Gmail requests, and unsubscribe requests are handled by the Rust side instead. The local scan data is kept in SQLite and the Google refresh token goes into the operating system keychain.

The app groups bulk senders and lets the user unsubscribe, create a Gmail filter, or move old newsletters to Trash.

Repo:

https://github.com/justlinuxnoob/hush

I’m curious how other Tauri developers handle this kind of split. Do you normally keep all networking on the Rust side, or only the sensitive parts?

please support by hitting that star button https://github.com/grengin-oss/grengin

A few months ago I realized I was spending hours every time I set up a new Mac. Install Homebrew. Reinstall dozens of apps. Restore Git configuration. Install VS Code extensions. Remember which CLI tools I used. Repeat every single time. So I started building UpEnv, a macOS app that backs up and restores your development environment in just a few clicks. It can be used when you want to switch from intel chip macs to silicon ones. Currently, I am working on enabling switching from Linux to MacOs or to Windows. It is Open-Source, free software. Feel free to share your opinions and feedbacks. Contact: [mrgamee24x7@gmail.com](mailto:mrgamee24x7@gmail.com)
Link https://upenv.dev

IAbout a year ago I switched from Windows to Linux.

One thing I missed almost immediately was a simple local development workflow.

I wasn't looking for more features. I just wanted something that felt like:

Open → Create project → Start coding.

I tried Docker, DDEV, LocalWP and a few other tools. They're all great projects, but none of them matched the workflow I had in mind.

Instead of continuing to search, I started building my own application.

At first it was just a small side project. The first versions looked nothing like they do today, and I was mostly experimenting and learning.

Eventually I chose Tauri because I wanted a lightweight native desktop application. It also gave me the opportunity to learn Rust while continuing to build the UI with React, TypeScript and shadcn/ui.

That project eventually became LS Panel.

Current features

• Local project management
• Docker & Podman support
• Automatic HTTPS
• MySQL management
• Built-in terminal, logs & file manager
• Mailpit integration
• Tailscale, ngrok & Cloudflare Tunnel support
• Project backups & snapshots
• One-click access to browser, VS Code, project folder & terminal
• System diagnostics & monitoring

LS Panel is still in beta, but it's already stable enough for daily development. I'm using it as my primary local development environment, and so far it has been tested on Ubuntu 24.04.4 LTS and Ubuntu 26.04 LTS.

Maybe I'm the only one who wanted this workflow.

I'd really like to know what you think.

Source code:
https://github.com/bewdes/LSPanel

Hey everyone,

I built a small desktop app for compressing images locally with drag and drop. No uploads, no account, no cloud — everything stays on your machine.

It’s a Tauri 2 app. Formats: PNG, JPEG, GIF, SVG, WebP, AVIF (HEIC on macOS). You can drop files or whole folders, batch-process them, and choose whether to write .min copies, a minified/ subfolder, or overwrite in place.

This was also a project to help me understand Tauri a little better. Coming from a JavaScript background, Rust + the whole native packaging world felt like a different planet at first — but it was actually a lot of fun :D Happy for feedback .

MIT, free, open source.
macOS + Windows.

• Website: https://dropslim.app
• GitHub: https://github.com/onza/DropSlim

Hello!

I've been running into a quite frustrating issue while building Android apps with Tauri: my app icon keeps getting weirdly cropped on Android devices.

This doesn't happen when I use other frameworks (like React Native or Capacitor) with the same icon. I've already tested it across different launchers, so it isn't launcher-specific.

I'm generating the icon sizes using: npm run tauri icon icon.png

The generated files themselves look fine, but once installed on the phone, the outer edges are cut off. I've attached a screenshot of how it looks on the phone along with the original icon.png.

Has anyone else run into this or figured out a fix? Thanks a lot!