Universal browser based Dark Mode (Dark Reader) vs. Individual separate black themes on each site

I’m pondering an idea about browser based, concentrated dark mode/dark theme service’s that operate pretty much like current superb add-on Dark Reader.

What makes me wonder why does the community that usually optimizes for not repeating work among developers, does take the burden of developing a dark theme for pretty much every popular web application.

Wouldn’t it be wiser to develop a set of standards when it comes to colour management, maybe even a .darktheme config file to override some of the basic settings, alongside a single browser based dark mode program for every browser that operates on the principle of current dark reader? I mean the reader is so good that I pretty much prefer it to custom made dark modes on most of the sites anyway.

What’s your insight on this matter?

My personal opinion is that it’s the inevitable future, but I haven’t found any signs that the process has started yet.

EDIT- before someone suggests sticking to the Dark Reader extension, It’s all good but compare a little a bit clunky extension developed by few enthusiasts to fully fledged browser options backed by hundreds of full-time developers.


ag.algebraic geometry – Are universal geometric equivalences of DM stacks affine?

Let $f:Xto Y$ be a map of Deligne-Mumford stacks. Let’s say that the map $f$ is a geometric equivalence if the induced map on small étale topoi is a geometric equivalence. Moreover, let’s say that the map $f$ is a universal geometric equivalence if for every morphism $Ato Y$ with $A$ an affine scheme, the projection map $Xtimes_Y A to A$ is a geometric equivalence (so without loss of generality, then, we can assume that $Y$ is affine). So then the question:

Is it true that given a universal geometric equivalence $f:Xto Y$, the map is an affine morphism?

It would in fact be enough to show that the map is schematic (using the classification of universal homeomorphisms between schemes together with the reduction to $Y$ affine), but I’m not sure if that’s so clear either.

Bonus question: If it is true for Deligne-Mumford stacks, does it remain true for algebraic stacks?

windows 10 – Universal Docking Station with Dell

I have Dell XPS 17 9700, with Windows 10 Professional, and I connected it to a universal docking station called Targus Dock177 which is compatible with DisplayLink.
It automatically detected the docking station and recognize all devices connected to it (two monitors, mouse, headphone….)
The Dell and docking station worked fine and smoothly for more than three months.
Dell detected automatically the Targus and monitors and connected them using “DisplayLink” driver

But suddenly today (12th January 2021) it doesn’t recognize the monitors anymore.
Mouse and headphone still working, but the monitors are not working.

if you check the devices with “Device Manager” you will see the two monitors under “Display Adapters” being faulty and has errors (two of them), and the error message is:

Windows has stopped this device because it has reported problems.
(Code 43)

I tried many things:

  1. restart the PC
  2. disabled the drivers and re-enable them
  3. uninstall the drivers and restart again and install them
  4. update the drivers (which they are up-to-date with displaylink drivers)

Every time I do that, it will go into a process that takes 2 minutes of flashing the monitors and popup of the taskbars, and at the end of two minutes it will just freeze the two monitors and only the laptop monitor works and only the laptop monitor get recognized, and the two monitors are not recognized.

When I try to detect the monitors I don’t see them , just the laptop monitor.

windows 10 – HP Elitebook 840 G4 on a Universal USB-C Dock

I have 2 Laptop PCs,

  1. HP Elitebook 840 G4 (for personal use)
  2. Lenovo T480 (for work use)

My Lenovo is connected to its USB-C Docking Station so it can project to 2 monitors.
I would like to use the same Dock on my HP Elitebook when I’m not working, but I found out my USB-C isn’t Thunderbolt-compatible: HP Elitebook 840 G4 Docking solution.

Though it seems I may not be able to project to dual monitors using this Dock, but i found that some other users were able to actually make their HP Elitebook 840 G4 work on a Universal Docking Station:


I’ve tried the DisplayLink approach and updated the drivers but it still isn’t working.
Is there any way I can “upgrade” my HP’s normal USB-C or USB-A to a Thunderbolt Port? Perhaps via a Software Upgrade or a connector dongle/adapter?

physics – Can one build a “mechanical” universal turing machine?

This question connects different disciplines so it’s awkward to choose a SE site for it, but I’ll go with this one because here (I hope) the shared culture will make information transfer easier.

So computers as we know them use electricity and I don’t know what other invisible things that I don’t understand. I was wondering, is this a matter of efficiency, or of necessity? Can one achieve universal computation with just “moving parts”? Perhaps “Newtonian physics” is some term for this, although I guess it includes gravity which isn’t really what I mean. You know, just good old solid pieces of matter moving around.

To get some picture of what I mean, here is a “LEGO turing machine”. I’m afraid that the big gray block on top uses electricity, but could one replace it with a “mechanical” thing, powered perhaps by rotating a piece? I have no idea how such things be designed, and the state transitions for a universal TM have to be fairly complicated, so I have no intuition for whether this is possible or not.

Is Universal Scene Description (USD) suitable for games?

I’ve been reading about Pixar’s Universal Scene Description (USD) system after seeing it in the package list inside Unity. All the material that I’ve read is within the context of the Film/Vfx industry with lots of focus on different teams working in the same larger scene.

From what I’ve seen the USD system has all the information that is commonly used in games but with the focus on film the frame budgets that these are designed to work with are huge when compared to games (minutes, hours and days vs milliseconds) which means that there are a lot of files and bits that make up a scene rather than the singular files that popular engines use (thinking of Unity and Unreal).

Ultimately I’m wondering if there is any reference material for how well this system works for games (with game industry practices and workflows) or if there are any engines which have support for USD as a primary means of representing a scene?

YUMI (Your Universal Multiboot Installer) | Nulled Scripts Download

File Size : 1.7 Mb

YUMI (Your Universal Multiboot Installer), is the successor to MultibootISOs.​

It can be used to create a Multiboot USB Flash Drive containing multiple operating systems, antivirus utilities, disc cloning, diagnostic tools, and more. Contrary to MultiBootISO’s which used grub to boot ISO files directly from USB, YUMI uses syslinux to boot extracted distributions stored on the USB device, and reverts to using grub to Boot Multiple ISO files from USB, if necessary.
Aside from a few distributions, all files are stored within the Multiboot folder, making for a nicely organized Multiboot Drive that can still be used for other storage purposes.

YUMI works much like Universal USB Installer, except it can be used to install more than one distribution to run from your USB. Distributions can also be uninstalled using the same tool!

Changed compiler and recompiled. No other source changes made.



.(tagsToTranslate)xenforo(t)xenforo themes(t)xenforo nulled(t)xenforo free(t)xenforo 2.2(t)nulled(t)nulled script(t)whmcs(t)whmcs nulled(t)scripts(t)nulled scripts(t)vbulletin(t)vbulletin nulled(t)vbulletin 5 nulled(t)xenforo resources(t)wordpress download(t)wordpress nulled forum

hashing – Universal hash functions – Proof

Problem statement

Let $K$ be a set of keys with $|K| = n$ and define the index set $I = {0, ldots, m-1}$. Now let $H = {h mid h : K to I}$, i.e. $H$ contains all hash functions which map the keys from $K$ to the set ${0, ldots, m-1}$.

Prove or disprove that $H$ is universal.


Reiterating the definition

A family of hash functions $H$ is universal if and only if for $forall x, y in K, (x neq y)$ we have
$left|{h in H : h(x) = h(y)}right| = frac{|H|}{m}$

I know you can construct specific families of universal hash functions and there are families which aren’t universal. But if you consider all of them how would you know which part would outweigh which to decide if this statement still holds?

I’m probably going the wrong way so I would appreciate any help or hints!

python – Universal class for proxifying poplib, imaplib and smtplib. Lame inheritance or mock or something else?

This is wrapper for POP3, POP3_SSL, IMAP4, IMAP4_SSL, SMTP and SMTP_SSL classes which let them work through proxies. For creating socket with proxy I’ve used PySocks.


from imaplib import IMAP4, IMAP4_SSL, IMAP4_PORT, IMAP4_SSL_PORT
from poplib import POP3, POP3_SSL, POP3_PORT, POP3_SSL_PORT
from smtplib import SMTP, SMTP_SSL, SMTP_PORT, SMTP_SSL_PORT
from socks import create_connection, PROXY_TYPE_HTTP, PROXY_TYPE_SOCKS4, PROXY_TYPE_SOCKS5
import socket
import sys
from urllib.parse import urlparse
from collections import namedtuple

def imap_before_connection(self, *args):
    sys.audit("imaplib.open", self, self.host, self.port)

def smtp_before_connection(self, host, port):
    if self.debuglevel > 0:
        self._print_debug('connect: to', (host, port), self.source_address)

def pop_before_connection(*args):

    POP3_SSL: (POP3_SSL_PORT, pop_before_connection),
    IMAP4_SSL: (IMAP4_SSL_PORT, imap_before_connection),
    SMTP_SSL: (SMTP_SSL_PORT, smtp_before_connection),
    POP3: (POP3_PORT, pop_before_connection),
    IMAP4: (IMAP4_PORT, imap_before_connection),
    SMTP: (SMTP_PORT, smtp_before_connection)

def proxify(base_type):
    for type_, (default_port, before_connection) in DEFAULT_SETTINGS.items():
        if issubclass(base_type, type_):
        raise TypeError(f"Can't proxify {base_type}")

    class Proxified(base_type):
        Proxy = namedtuple("Proxy", ("host", "port", "username", "password", "proxy_type", "rdns"))
        on_before_connection = before_connection

        def parse_proxy_string(proxy_string):
            if not proxy_string:
                return None

            parsed = urlparse(proxy_string)
            _scheme = parsed.scheme.lower()
            if _scheme in {"http", "https"}:
                proxy_type, remote_dns = PROXY_TYPE_HTTP, True
            elif _scheme in {"socks4", "socks4a"}:
                proxy_type, remote_dns = PROXY_TYPE_SOCKS4, _scheme.endswith("a")
            elif _scheme in {"socks5", "socks5h"}:
                proxy_type, remote_dns = PROXY_TYPE_SOCKS5, _scheme.endswith("h")
                raise ValueError(f'"{_scheme}" is not supported proxy type')

            return Proxified.Proxy(parsed.hostname, parsed.port, parsed.username, parsed.password,
                                   proxy_type, remote_dns)

        def __init__(self, host="", port=default_port, *args, **kwargs):
            self.proxy = self.parse_proxy_string(kwargs.pop("proxy", ""))

            super().__init__(host, port, *args, **kwargs)

        def _create_socket(self, timeout):  # used in POP3 and IMAP
            return self._get_socket(self.host, self.port, timeout)

        def _get_socket(self, host, port, timeout):  # used in SMTP
            if timeout is not None and not timeout:
                raise ValueError('Non-blocking socket (timeout=0) is not supported')

            self.on_before_connection(self, host, port)

            if not self.proxy:
                sock = socket.create_connection(
                    (host, port),
                    getattr(self, "source_address", None)
                sock = create_connection(  # socks.create_connection
                    (host, port),
                    getattr(self, "source_address", None),

            ssl_context = getattr(self, "context", None) or getattr(self, "ssl_context", None)
            if ssl_context:
                return ssl_context.wrap_socket(sock, server_hostname=host)
                return sock

    return Proxified


from imaplib import IMAP4, IMAP4_SSL
from poplib import POP3, POP3_SSL
from smtplib import SMTP, SMTP_SSL

mail, mail_pass = "email@example.com", "password"
http_proxy = "http://username:password@"
pop_server = "pop.example.com"
imap_server = "imap.example.com"
smtp_server = "smtp.example.com"

pop_handler = proxify(POP3)(pop_server, proxy=http_proxy)
pop_secure_handler = proxify(POP3_SSL)(pop_server, proxy=http_proxy)
imap_handler = proxify(IMAP4)(imap_server, proxy=http_proxy)
imap_secure_handler = proxify(IMAP4_SSL)(imap_server, proxy=http_proxy)
smtp_handler = proxify(SMTP)(smtp_server, proxy=http_proxy)
smtp_secure_handler = proxify(SMTP_SSL)(smtp_server, proxy=http_proxy)

It works and works good but I look on this code and .. I feel that solution is a bit cumbersome.

Could you please take a look on it and point me what I’ve done in “wrong” way and suggest the correct way. Thanks.


There’s also another option which looks much better (imho), but it uses mock.patch() and I’m not quite sure that it’s okay to use it in production.


from poplib import POP3
from imaplib import IMAP4
from smtplib import SMTP
from functools import wraps, partial
from collections import namedtuple
from unittest.mock import patch
from urllib.parse import urlparse
from socks import create_connection, PROXY_TYPE_HTTP, PROXY_TYPE_SOCKS4, PROXY_TYPE_SOCKS5

def mock_if_proxy(method):
    def wrapper(self, *args, **kwargs):
        if self.proxy:
            with patch("socket.create_connection",
                       partial(create_connection, proxy_type=self.proxy.proxy_type, proxy_addr=self.proxy.host,
                               proxy_port=self.proxy.port, proxy_rdns=self.proxy.rdns,
                               proxy_username=self.proxy.username, proxy_password=self.proxy.password)):
                return method(self, *args, **kwargs)
            return method(self, *args, **kwargs)
    return wrapper

def proxify(base_type):
    if not issubclass(base_type, (POP3, IMAP4, SMTP)):
        raise TypeError(f"Can't proxify {base_type}")

    class Proxified(base_type):
        # skipped Proxy and parse_proxy_string() declaration, it's the same

        if hasattr(base_type, "_create_socket"):
            _create_socket = mock_if_proxy(base_type._create_socket)
        if hasattr(base_type, "_get_socket"):
            _get_socket = mock_if_proxy(base_type._get_socket)

        def __init__(self, *args, **kwargs):
            self.proxy = self.parse_proxy_string(kwargs.pop("proxy", ""))

            super().__init__(*args, **kwargs)

    return Proxified

Maybe you could advice me a better way without mock?