Blog

Top 7 Features of BEI Payroll and How to Use Them

1. Automated payroll processing

• What it does: Calculates gross pay, deductions, taxes, and net pay automatically.
• How to use: Set up pay schedules, employee pay rates and deduction rules once; run scheduled or ad-hoc payroll runs and review the pre-submit audit before finalizing.

2. Tax calculation and filing

• What it does: Applies current federal, state, and local tax tables and can prepare or file returns.
• How to use: Enter company tax IDs and filing preferences, enable automated tax updates, and choose e-file or manual review for each return.

3. Direct deposit and payment options

• What it does: Sends wages via ACH/direct deposit; supports paper checks and pay cards.
• How to use: Collect employee bank details in secure ESS, verify micro‑deposits if required, and select payment method at payroll run.

4. Time tracking integration

• What it does: Imports hours from time clocks/timesheets (or built‑in timekeeping) to remove manual entry and calculate overtime.
• How to use: Connect your timekeeping system or enable BEI’s time module, map pay codes, approve timesheets, then sync to payroll.

5. Employee self‑service (ESS)

• What it does: Lets employees view pay stubs, tax forms, update personal info, and request PTO.
• How to use: Enable ESS access, invite employees, set permissions, and provide onboarding steps (verify direct deposit, W‑4, bank info).

6. Reporting & analytics

• What it does: Generates payroll journals, labor cost reports, tax liability summaries, and customizable exports for accounting.
• How to use: Use built‑in templates for common reports, set scheduled report delivery, and export GL mappings to your accounting system.

7. Compliance & audit features

• What it does: Maintains audit trails, stores tax forms (W‑2/1099), supports new‑hire reporting and wage garnishments.
• How to use: Keep employee records up to date, enable automatic new‑hire/state reporting, review audit logs before year‑end, and configure garnishment rules per case.

How to Get the Best Results with YoGen Vocoder: Workflow & Settings

1) Signal routing (foundation)

• Carrier: Use a harmonically rich synth (saw/stacked saws, supersaw, FM pad) or layered synth + subtle sub. Route carrier to the vocoder’s carrier input.
• Modulator: Use clean, dry vocal (mono or stereo) with moderate compression and de-essing. Route to the vocoder’s modulator input.
• Sidechain option: If your DAW/vocoder supports sidechain, send the vocal as sidechain/modulator rather than inserting the vocoder on the synth track.

2) Pre-processing the vocal (modulator prep)

• High-pass filter: 80–120 Hz to remove low rumble that muddies bands.
• De-esser: 5–8 dB reduction around sibilance frequencies.
• Compression: Light ratio 2:1–3:1, medium attack and release to balance dynamics while keeping articulation.
• EQ: Slight boost 1–4 kHz for intelligibility; cut 250–500 Hz if boxy.

3) Carrier sound design

• Harmonic content: Add detuned oscillators, mild FM, or rich filter drive to ensure strong carrier energy across bands.
• Filtering: Low-pass around 10–12 kHz if harsh; keep low end if you want body (or high-pass under 80 Hz to avoid conflict).
• Unison/Detune: 2–8 voices depending on thickness desired; more voices = smoother formant rendering but can blur consonants.

4) YoGen vocoder core settings (typical starting point)

• Bands: 16–32 bands — 16 for vintage robotic tone; 24–32 for clearer intelligibility.
• Formant shift: 0 (neutral) to ±2 semitones for subtle gendering; ±12+ for extreme effects.
• Envelope follow / attack: Fast (0–30 ms) for crisp consonants; slower (50–150 ms) for smoother, pad-like output.
• Release: 100–300 ms to avoid choppy tails; shorter for rhythmic effects.
• Band smoothing: Moderate (if available) to reduce zipper noise between bands.
• Wet/dry blend: Start 100% wet on a dedicated effect bus, then blend with dry vocal or synth to taste (30–70% wet for clarity).

5) Managing intelligibility vs. texture

• For maximum intelligibility: more bands (24–32), faster attack, minimal unison on carrier, and keep some dry vocal layered under the vocoded signal.
• For texture/ambience: fewer bands (8–16), slower attack/release, lush detuned carrier, reverb/delay after vocoder.

6) Effects chain recommendations (order matters)

• Insert chain if vocoder is an insert on the carrier:
  1. Carrier synth (sound design)
  2. YoGen Vocoder
  3. EQ (post—gentle high-shelf or mid tweaks)
  4. Compressor (glue)
  5. Time-based FX: chorus → reverb → delay
  6. Final limiter or transient shaping
• Bus approach (recommended for clarity): send carrier to bus with YoGen; keep vocal dry on original track and parallel-compress or EQ to preserve articulation.

7) Advanced tips

• Vowel shaping: Automate formant shift or band emphasis to change vowel character over time.
• Sidechain gating: Use vocal envelope to gate synth before the vocoder for tight rhythmic effects.
• Pitch tracking: If YoGen supports pitch follow, enable for monophonic melodic control (good for talkbox-like leads).
• Noise layer: Add subtle noise or breath layer under vocoded output to retain natural consonant texture.
• Automation: Automate wet/dry, formant, and band count across sections (verse = sparse; chorus = full).
• Resampling: Print vocoded parts and resample with additional processing (vintage saturation, granular chops).

8) Quick presets to try

• Classic Robot: 16 bands, fast attack (10–20 ms), release 120 ms, neutral formant, carrier = saw stack, mild reverb.
• Choir Pad: 24–32 bands, slow attack (80–150 ms), long release (300–600 ms), +2 semitones formant, lush unison carrier, heavy reverb.
• Talkbox Lead: 12–16 bands, fast attack, short release, slight formant boost, carrier = single-oscillator with formant filter, add delay.

9) Final mixing checklist

• Check intelligibility at low listening levels.
• Balance wet/dry so vocal lyrics remain readable in verses.
• Carve space with subtractive EQ (cut competing mids from other instruments).
• Mono-check for phase issues; adjust band smoothing or stereo width on carrier if grabby in mono.

If you want, I can produce a one-page preset map (exact parameter values) tailored to your DAW or to YoGen’s UI labels.

How Stream-Cloner Lets You Save Streaming Videos in Seconds

Saving streaming videos quickly and reliably has become essential for users who want offline access, archiving, or editing clips. Stream-Cloner is a focused tool designed to capture and save streaming media with speed and simplicity. This article explains how Stream-Cloner achieves near-instant downloads, the main features that enable fast saves, and smart tips to get the most out of it.

How it works — the speedy basics

• Direct stream capture: Stream-Cloner intercepts the video/audio stream directly from the source URL or browser session, avoiding time-consuming re-encoding or intermediate downloads.
• Parallel segment fetching: For segmented streaming protocols (HLS/DASH), Stream-Cloner requests multiple segments in parallel, reducing total download time.
• Smart buffering and caching: It buffers incoming data efficiently and writes to disk incrementally, so saving begins immediately rather than waiting for the full stream.
• Hardware acceleration (when available): Offloading encoding or container muxing to the GPU or dedicated hardware speeds up any necessary processing.

Key features that cut save time

• One-click capture: Start saving a stream instantly from the app or browser extension—no manual URL parsing required.
• Auto-detect streaming formats: Automatic detection of HLS, DASH, RTMP, and progressive MP4 means the tool chooses the fastest capture method.
• Adaptive bitrate handling: Downloads the highest available quality while switching seamlessly across bitrates to avoid stalls.
• Batch and scheduled captures: Queue multiple streams or schedule captures to run during off-peak hours without manual intervention.
• Fast muxing and remuxing: Quickly package audio and video into common containers (MP4, MKV) without full transcoding, preserving speed and quality.

Practical workflow — save a stream in seconds

1. Install and open Stream-Cloner (or add the browser extension).
2. Navigate to the streaming page and click the Stream-Cloner capture button or paste the stream URL into the app.
3. Choose quality and container (default settings typically select the fastest option).
4. Click Save — Stream-Cloner begins parallel fetching and writes data to disk immediately.
5. Play or edit the saved file once the muxing step completes (often while download is still finishing for long streams).

Tips to maximize speed and reliability

• Use a wired connection when possible to ensure stable throughput.
• Enable multiple connections in settings to increase parallel segment fetching.
• Select remux instead of transcode to avoid slow re-encoding when format compatibility is sufficient.
• Limit CPU-heavy tasks during captures to keep disk and processor performance focused on the download.
• Check for updates—newer versions often improve protocol support and speed.

Legal and ethical reminder

Only save streams when you have the right to do so—personal offline viewing, content you own, or material explicitly permitted by the rights holder. Respect terms of service and copyright laws.

Conclusion

Stream-Cloner combines direct capture, parallel fetching, intelligent buffering, and fast muxing to let users save streaming videos in seconds. With one-click capture, format auto-detection, and practical settings for speed, it’s a solid choice for anyone needing quick, reliable offline copies of streaming media.

Boost Productivity: 7 Plugins and Shortcuts for Database Studio

Working efficiently in Database Studio means combining the right plugins with a few powerful shortcuts. Below are seven plugins and shortcuts that streamline querying, navigation, and schema management so you spend less time on routine tasks and more time solving problems.

1. SQL Snippet Manager (Plugin)

• Why it helps: Stores reusable query templates and parameterized snippets.
• Use case: Save common JOINs, CTEs, or reporting queries to paste and adapt quickly.
• Tip: Create categorized folders (e.g., analytics, maintenance, ETL) and assign keyboard shortcuts to your top 5 snippets.

2. Schema Visualizer (Plugin)

• Why it helps: Generates interactive ER diagrams from live schemas.
• Use case: Quickly trace relationships when designing joins or refactoring tables.
• Tip: Use diagram filtering to hide system tables and export PNG/SVG for documentation.

3. Query History + Diff Viewer (Plugin)

• Why it helps: Keeps a searchable history of executed queries and shows diffs between versions.
• Use case: Recover a lost query or compare incremental edits in complex analytics work.
• Tip: Enable timestamps and tag entries with project names for faster retrieval.

4. Connection Profiles & Auto-Reconnect (Plugin)

• Why it helps: Manages multiple DB credentials and automatically reconnects dropped sessions.
• Use case: Switch between dev/stage/prod with one click and avoid losing long-running work.
• Tip: Secure profiles with the built-in vault and set idle reconnect thresholds conservatively.

5. Inline Data Preview (Plugin)

• Why it helps: Shows a sampled preview of results inline as you write queries without executing full scans.
• Use case: Validate column types and spot obvious data issues before running heavy queries.
• Tip: Configure sampling size per connection to balance speed and representativeness.

6. Shortcut: Multi-line Block Comment Toggle

• Why it helps: Quickly comment/uncomment blocks during debugging or iterative development.
• How to use: Select lines and press the configured toggle (e.g., Ctrl+/ or Ctrl+Shift+/).
• Tip: Combine with snippet placeholders to scaffold tests within queries.

7. Shortcut: Jump to Definition (Table/Function)

• Why it helps: Instantly open table definitions, indexes, or function bodies from references in SQL.
• How to use: Place cursor on identifier and press the shortcut (e.g., F12).
• Tip: Use it alongside the Schema Visualizer to confirm relationships and constraints.

Quick Setup Checklist

• Install Snippet Manager, Schema Visualizer, Query History, Connection Profiles, and Inline Preview.
• Assign shortcuts: snippet insert, comment toggle, jump-to-definition.
• Create snippet folders and a naming convention: project_env_purpose (e.g., analytics_prod_top_customers).
• Secure connection profiles in the vault and enable auto-reconnect.

Final Workflow Example (5 minutes)

1. Open Database Studio and switch to your project connection profile.
2. Insert a saved snippet for the base query.
3. Use inline data preview to verify sample results.
4. Jump to definition for any unclear table references.
5. Edit and comment blocks with the comment toggle; save variations to Query History.
6. Export ER diagram if schema changes need documentation.

Implementing these plugins and shortcuts should cut repetitive work, reduce errors, and let you focus on higher-value database tasks.

Visual TimeAnalyzer Portable — Review: Features, Pros & Cons

Features

• Automatic activity logging: Records application, document and website use without manual start/stop.
• Portable mode: Runs from a folder/USB without installation; settings and logs travel with the app.
• Visual reports: Colorful charts, timetables and weekly/hourly breakdowns (exportable as HTML, TXT, CSV and BMP).
• Multi-user / network analysis: Aggregate and compare activity across workstations on a network.
• Project & cost tracking: Assign time to projects, add comments and calculate project costs.
• Idle/active detection: Separates active working time from idle periods.
• Data protection options: Does not log keystrokes; recorded data can be password-protected.
• Lightweight system requirements: Small footprint (≈1.7–1.8 MB), supports Windows (XP → Windows ⁄₁₀ on vendor pages).

Pros

• Clear, visual presentation makes patterns and time sinks easy to spot.
• Works without installation — convenient for temporary or multi-machine use.
• Exports data for external analysis or reporting.
• Useful for personal productivity, parental oversight, or small business monitoring.
• One-time license (no subscription) and low disk footprint.

Cons

• Monitoring nature can raise privacy and ethical concerns in shared/work environments.
• Some users report bugs and limited vendor responsiveness/support.
• Portable setup may require manual configuration for networked monitoring.
• Trial has limitations (nag screen, 30-day trial); full features require purchase.
• Older codebase — occasional compatibility or stability issues reported on some systems.

If you want, I can summarize suitability for personal use, business use, or suggest modern alternatives.

Best Practices for File Encryption/Decryption in 2026

Why strong file encryption matters

Encrypted files protect confidentiality when data is stored, shared, or backed up. In 2026, threats include sophisticated ransomware, supply-chain compromises, and targeted data exfiltration. Proper encryption reduces risk of exposure and helps meet regulatory and contractual requirements.

Choose the right algorithms and key sizes

• Use modern, vetted algorithms: AES-256 (symmetric) and X25519 / NIST P-384 or RSA-4096 (asymmetric) for compatibility where needed. Prefer elliptic-curve crypto (X25519/Ed25519) for key exchange/signing when supported.
• Avoid deprecated algorithms: Do not use DES, 3DES, RC4, or MD5-based schemes.
• Key length: Use at least AES-256 for long-term confidentiality; choose curve-based keys (X25519/Ed25519) for performance and security.

Prefer authenticated encryption

• Authenticated modes: Use AES-GCM or ChaCha20-Poly1305 to provide both confidentiality and integrity. Authenticated encryption prevents undetected tampering and most padding-oracle style attacks.

Key management is the core

• Generate keys securely: Use OS-provided or hardware RNGs (e.g., /dev/urandom, CryptGenRandom, getrandom, or platform cryptography APIs).
• Limit key exposure: Store keys only where necessary. Use hardware security modules (HSMs), secure elements, or OS key stores (e.g., Windows DPAPI/Keystore, macOS Keychain, Linux seahorse with TPM integration) for long-term keys.
• Rotate keys periodically: Schedule key rotation and have procedures to re-encrypt or re-wrap keys.
• Split secrets when needed: Use Shamir’s Secret Sharing or multi-party HSMs for high-value secrets.
• Backup keys securely: Keep encrypted key backups in a separate, secure location with strict access controls.

Use well-reviewed libraries and avoid rolling your own

• Prefer high-level, maintained libraries: libsodium, OpenSSL (modern versions with correct API usage), BoringSSL, or platform-native crypto frameworks.
• Use high-level APIs: Higher-level constructs reduce misuse (e.g., libsodium’s secretbox or crypto_aead). Avoid low-level primitives unless you have crypto expertise.
• Keep libraries updated: Apply security patches promptly; many vulnerabilities come from outdated crypto libraries.

Protect metadata and filenames

• Encrypt filenames and metadata when possible: Filesystems and archive tools often leak names, sizes, timestamps, and directory structure. Use encrypted containers (e.g., VeraCrypt, age with archive encryption workflows) or tools that support filename encryption.
• Pad or chunk files to hide exact sizes: Consider fixed-size chunking or padding strategies when adversaries might infer contents from file size.

Use end-to-end encryption for sharing

• Encrypt before uploading: Always encrypt sensitive files locally before cloud upload. Relying on provider-side encryption alone risks exposure from misconfigurations or provider access.
• Key exchange & verification: Use authenticated key exchange (e.g., X25519 with signatures) and verify keys out-of-band or via trust-on-first-use (TOFU) with manual confirmation for high-sensitivity sharing.

Automate securely

• Script with secure defaults: Automations (backups, data pipelines) should use secure key storage, least-privilege service accounts, and rotate credentials.
• Audit logs and alerts: Monitor encryption/decryption operations and key usage for anomalies. Keep logs tamper-evident (immutability, remote logging).

Secure file deletion and lifecycle

• Encrypt-at-rest plus secure deletion: When deleting encrypted files, securely wipe key material and, if required, file contents. For SSDs, use crypto-erase (discard encryption keys) or vendor tools—full physical overwrite may not be practical.
• Define retention and destruction policies: Map data lifecycle to encryption, key retention, and destruction procedures.

Access controls and least privilege

• Limit who can decrypt: Enforce RBAC and MFA for key access. Use per-user or per-service keys rather than shared keys when feasible.
• Use auditability: Track who accessed or decrypted files and when; integrate with existing SIEM or audit systems.

Protect against common operational mistakes

• Avoid hardcoding keys: Never embed secrets in source code or container images. Use secret managers (Vault, AWS KMS/Secrets Manager, GCP KMS/Secret Manager) properly.
• Careful with backups: Ensure backups are encrypted and keys for backups are stored separately from primary keys.
• Test recovery: Regularly exercise key recovery and decryption workflows to ensure backups and rotations work.

Embrace post-quantum readiness (practical steps)

• Assess exposure: Most file encryption using symmetric keys (AES-256) remains safe against near-term quantum threats; focus on asymmetric workflows (key exchange, signatures).
• Hybrid approaches: Where appropriate, use hybrid solutions that combine classical (e.g., X25519) and post-quantum algorithms (e.g., Kyber-style KEM) to hedge risks. Use well-vetted libraries and standards for PQC rather than experimental roll-your-own.

Practical example: simple secure workflow (conceptual)

1. Generate a strong symmetric key with a secure RNG.
2. Encrypt file with AES-256-GCM or ChaCha20-Poly1305, producing ciphertext + auth tag.
3. Encrypt (wrap) the symmetric key with the recipient’s public key (X25519/recipient’s public key) or protect with an HSM.
4. Store ciphertext, wrapped key, and minimal necessary metadata.
5. Verify decryption by checking the auth tag; log successful operations.

Quick checklist before deploying

• Algorithms: AES-GCM or ChaCha20-Poly1305; X25519/Ed25519 for asymmetric.
• Libraries: Use libsodium or updated OpenSSL/BoringSSL.
• Key storage: HSM/OS keystore/secure vault.
• Metadata: Encrypt filenames where possible.
• Automation: Secure defaults, secret manager integration.
• Testing: Recovery drills and library updates.

Following these practices in 2026 will help ensure your file encryption and decryption are robust, maintainable, and resilient against current threats.

ShellWM vs. Other Tiling Window Managers — Performance & Features Compared

Summary: ShellWM is an older Windows-focused skinning/window-manager project (last public activity ~2013 on SourceForge) and not a modern Linux tiling WM like i3, bspwm, Sway, or Hyprland. Below is a concise comparison focusing on platform, resource use, configuration, tiling model, extensibility, and current maintenance.

1TabView: A Complete Guide to Features and Setup

What 1TabView is (assumption)

• 1TabView appears to refer to a “tab view” UI pattern or component (commonly named TabView in frameworks such as SwiftUI, WinUI, and web UI libraries). This guide assumes 1TabView is a tabbed interface component used to switch between multiple content panels in an app or website.

Key features

• Multiple tabs: Hold and switch between distinct content panels.
• Tab headers: Labels and optional icons for quick recognition.
• Lazy loading: Load tab content only when selected (performance).
• Closable tabs: User can close tabs (browser-like behavior).
• Reorder / drag‑and‑drop: Rearrange tabs via dragging.
• Tear‑out / new window: Optionally detach a tab into its own window.
• Keyboard navigation: Arrow keys, Ctrl/Cmd+Number to select tabs, Esc to close.
• Badges / notifications: Small indicators on tab headers (unread counts).
• Accessibility: ARIA roles / platform accessibility support.
• Theming & styling: Customize colors, shapes, and animations for the tab bar and content.

Typical setup (web / JS library example)

1. Install package (example):
   • npm: npm install 1tabview (replace with actual package name).
2. Import component:

   js
   Copy CodeCopied
   import { TabView, Tab } from ‘1tabview’;
   

3. Basic usage:

   jsx
   Copy CodeCopied
   <TabView defaultIndex={0}>
   <Tab title=“Home” icon=“home”><Home /></Tab>
     <Tab title=“Profile” icon=“user”><Profile /></Tab>
     <Tab title=“Settings” icon=“cog”><Settings /></Tab>
   </TabView>
   

4. Enable lazy loading:

   jsx
   Copy CodeCopied
   <TabView lazy>
     … </TabView>
   

5. Add closable tabs:

   jsx
   Copy CodeCopied
   <Tab closable>Chat</Tab>
   

6. Handle events:

   js
   Copy CodeCopied
   <TabView onChange={(index) => console.log(‘selected’, index)}
            onClose={(index) => removeTab(index)} />
   

Typical setup (SwiftUI / Apple platforms)

1. Basic TabView:

   swift
   Copy CodeCopied
   TabView {
     HomeView()
       .tabItem { Label(“Home”, systemImage: “house”) }
     ProfileView()
       .tabItem { Label(“Profile”, systemImage: “person”) }
   }
   

2. Limit tabs (Apple HIG): aim for up to 5 on iPhone.
3. Use accessibility labels and .badge(…) for notifications.

Configuration options to look for

• Default/selected index
• Lazy/eager rendering
• Closable & draggable
• Animation duration/type
• Responsive layout (overflow handling)
• Persistence (remember last-open tab)
• Callbacks: onSelect, onClose, onReorder, onTearOut

Best practices

• Keep tabs few and distinct: 3–7 meaningful tabs.
• Use concise titles and icons.
• Avoid putting primary actions in the tab bar.
• Provide keyboard shortcuts and ARIA roles for accessibility.
• Lazy-load heavy content to improve startup performance.
• Persist user preference for last-selected tab when appropriate.

Troubleshooting tips

• Tabs not switching: check selected index binding and event handlers.
• Performance lag: enable lazy rendering or virtualize heavy content.
• Accessibility issues: ensure proper roles (tablist, tab,tabpanel) and focus management.
• Styling conflicts: use component-provided theme tokens or scoped CSS to avoid global overrides.

If you want, I can:

• Create a concrete code example for React, Vue, or SwiftUI tailored to your project.
• Draft documentation for a specific 1TabView package or internal component (assume React unless you request otherwise).

FileTime vs. Unix Time: Key Differences and Conversion Methods

What each format is

• FileTime (Windows FILETIME): 64-bit integer counting 100-nanosecond intervals since 00:00:00 UTC on January 1, 1601 (Gregorian). Used by NTFS, Win32 APIs, and Windows runtimes.
• Unix Time (POSIX/time_t): integer (commonly 32‑ or 64‑bit) counting seconds since 00:00:00 UTC on January 1, 1970. Widely used on Unix-like systems and in many programming languages.

Key differences

• Epochs: FileTime epoch = 1601-01-01; Unix epoch = 1970-01-01.
• Resolution: FileTime = 100 ns (10^-7 s) ticks; Unix time = 1 s (though many modern APIs support subsecond precision as float or separate fields).
• Range: FILETIME’s 64-bit ticks cover far wider date range than 32-bit Unix time (which overflows in 2038). 64-bit time_t avoids that overflow.
• Typical storage/representation: FileTime uses two 32-bit fields (dwLowDateTime, dwHighDateTime) or a 64-bit integer; Unix time commonly a single signed integer/64-bit integer or a floating-point seconds value for fractions.
• Time zone: Both measure absolute UTC instants; localized display requires conversion to local time separately.

Conversion basics (math)

• Ticks per second = 10,000,000 (because each tick = 100 ns).
• Offset between epochs (in FILETIME ticks) = 116444736000000000. This equals the number of 100‑ns intervals from 1601-01-01 to 1970-01-01.

Formulas:

• FILETIME (ticks) -> Unix seconds: unix_seconds = (filetime_ticks – 116444736000000000) / 10_000_000
• Unix seconds -> FILETIME ticks: filetime_ticks = unix_seconds10_000_000 + 116444736000000000
• For subsecond precision using milliseconds or nanoseconds, multiply/divide accordingly (e.g., multiply unix seconds by 1_000 to get milliseconds, by 1_000_000000 for nanoseconds).

c
 ffON2NH02oMAcqyoh2UU MQCbz04ET5EljRmK3YpQ CPXAhl7VTkj2dHDyAYAf” data-copycode=“true” role=“button” aria-label=“Copy Code”>Copy CodeCopied
// FILETIME -> unix time (seconds)
int64_t filetime_to_unix(uint64_t ft) {
    const uint64_t EPOCH_DIFF = 116444736000000000ULL;
    return (int64_t)((ft - EPOCH_DIFF) / 10000000ULL);
}

// unix time (seconds) -> FILETIME
uint64_t unix_to_filetime(int64_t unix_sec) {
    const uint64_t EPOCH_DIFF = 116444736000000000ULL;
    return (uint64_t)unix_sec  10000000ULL + EPOCHDIFF;
}

csharp
 ffON2NH02oMAcqyoh2UU MQCbz04ET5EljRmK3YpQ CPXAhl7VTkj2dHDyAYAf” data-copycode=“true” role=“button” aria-label=“Copy Code”>Copy CodeCopied
// From FileTime (long) to DateTime
DateTime dt = DateTime.FromFileTimeUtc(filetimeLong);

// From DateTime or Unix seconds to FileTime
long ft = dt.ToFileTimeUtc();
// or from unix seconds:
long ft2 = unixSeconds  10_000000L + 116444736000000000L;

powershell
 ffON2NH02oMAcqyoh2UU MQCbz04ET5EljRmK3YpQ CPXAhl7VTkj2dHDyAYAf” data-copycode=“true” role=“button” aria-label=“Copy Code”>Copy CodeCopied
# FILETIME -> DateTime
[datetime]::FromFileTimeUtc(130927962789982434)

# Unix seconds -> DateTime
[datetime]::UnixEpoch.AddSeconds(1610000000)

python
Copy CodeCopied
# FILETIME ticks -> unix seconds
EPOCH_DIFF = 116444736000000000
unix = (filetime_ticks - EPOCH_DIFF) / 10_000_000

# unix seconds -> FILETIME
filetime = int(unix_seconds * 10_000_000) + EPOCH_DIFF