diff --git a/README.adoc b/README.adoc
index 05da93e19..4a3a047ce 100644
--- a/README.adoc
+++ b/README.adoc
@@ -29,19 +29,18 @@ SQLite JDBC is a library for accessing SQLite databases through the JDBC API. Fo
 
 . <<Download,Download>> `sqlite-jdbc-{project-version}.jar`
 then append this jar file into your classpath.
-. https://search.maven.org/remotecontent?filepath=org/slf4j/slf4j-api/1.7.36/slf4j-api-1.7.36.jar[Download] `slf4j-api-1.7.36.jar` then append this jar file into your classpath.
 . Open a SQLite database connection from your code. (see the example below)
 
 === Example usage
 
-Assuming `sqlite-jdbc-{project-version}.jar` and `slf4j-api-1.7.36.jar` are placed in the current directory.
+Assuming `sqlite-jdbc-{project-version}.jar` is placed in the current directory.
 
 [source,shell,subs="attributes+"]
 ----
 > javac Sample.java
-> java -classpath ".;sqlite-jdbc-{project-version}.jar;slf4j-api-1.7.36.jar" Sample   # in Windows
+> java -classpath ".;sqlite-jdbc-{project-version}.jar" Sample   # in Windows
 or
-> java -classpath ".:sqlite-jdbc-{project-version}.jar:slf4j-api-1.7.36.jar" Sample   # in macOS or Linux
+> java -classpath ".:sqlite-jdbc-{project-version}.jar" Sample   # in macOS or Linux
 name = leo
 id = 1
 name = yui
diff --git a/pom.xml b/pom.xml
index 7f3d2782e..bee67a8c5 100644
--- a/pom.xml
+++ b/pom.xml
@@ -415,6 +415,7 @@
             <groupId>org.slf4j</groupId>
             <artifactId>slf4j-api</artifactId>
             <version>1.7.36</version>
+            <optional>true</optional>
         </dependency>
         <!--
         This dependency makes compilation on non-GraalVM versions possible.
diff --git a/src/main/java/org/sqlite/JDBC.java b/src/main/java/org/sqlite/JDBC.java
index 42f4499f4..b6419dede 100644
--- a/src/main/java/org/sqlite/JDBC.java
+++ b/src/main/java/org/sqlite/JDBC.java
@@ -18,12 +18,12 @@
 
 import java.sql.*;
 import java.util.Properties;
-import java.util.logging.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.jdbc4.JDBC4Connection;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 
 public class JDBC implements Driver {
-    private static final org.slf4j.Logger logger = LoggerFactory.getLogger(JDBC.class);
+    private static final Logger logger = LoggerFactory.getLogger(JDBC.class);
     public static final String PREFIX = "jdbc:sqlite:";
 
     static {
@@ -49,7 +49,7 @@ public boolean jdbcCompliant() {
         return false;
     }
 
-    public Logger getParentLogger() throws SQLFeatureNotSupportedException {
+    public java.util.logging.Logger getParentLogger() throws SQLFeatureNotSupportedException {
         // TODO
         return null;
     }
diff --git a/src/main/java/org/sqlite/SQLiteJDBCLoader.java b/src/main/java/org/sqlite/SQLiteJDBCLoader.java
index e054eedd3..5af86b436 100644
--- a/src/main/java/org/sqlite/SQLiteJDBCLoader.java
+++ b/src/main/java/org/sqlite/SQLiteJDBCLoader.java
@@ -39,9 +39,9 @@
 import java.util.Properties;
 import java.util.UUID;
 import java.util.stream.Stream;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.util.LibraryLoaderUtil;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 import org.sqlite.util.OSInfo;
 import org.sqlite.util.StringUtils;
 
diff --git a/src/main/java/org/sqlite/core/NativeDB.java b/src/main/java/org/sqlite/core/NativeDB.java
index f23269db6..4eef21638 100644
--- a/src/main/java/org/sqlite/core/NativeDB.java
+++ b/src/main/java/org/sqlite/core/NativeDB.java
@@ -19,14 +19,14 @@
 import java.nio.ByteBuffer;
 import java.nio.charset.StandardCharsets;
 import java.sql.SQLException;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.BusyHandler;
 import org.sqlite.Collation;
 import org.sqlite.Function;
 import org.sqlite.ProgressHandler;
 import org.sqlite.SQLiteConfig;
 import org.sqlite.SQLiteJDBCLoader;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 
 /** This class provides a thin JNI layer over the SQLite3 C API. */
 public final class NativeDB extends DB {
diff --git a/src/main/java/org/sqlite/jdbc3/JDBC3DatabaseMetaData.java b/src/main/java/org/sqlite/jdbc3/JDBC3DatabaseMetaData.java
index 1a2229c79..3958d28a2 100644
--- a/src/main/java/org/sqlite/jdbc3/JDBC3DatabaseMetaData.java
+++ b/src/main/java/org/sqlite/jdbc3/JDBC3DatabaseMetaData.java
@@ -21,12 +21,12 @@
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import java.util.stream.Collectors;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.SQLiteConnection;
 import org.sqlite.core.CoreDatabaseMetaData;
 import org.sqlite.core.CoreStatement;
 import org.sqlite.jdbc3.JDBC3DatabaseMetaData.ImportedKeyFinder.ForeignKey;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 import org.sqlite.util.QueryUtils;
 import org.sqlite.util.StringUtils;
 
diff --git a/src/main/java/org/sqlite/jdbc3/JDBC3Statement.java b/src/main/java/org/sqlite/jdbc3/JDBC3Statement.java
index 69cadf72b..a634f3afa 100644
--- a/src/main/java/org/sqlite/jdbc3/JDBC3Statement.java
+++ b/src/main/java/org/sqlite/jdbc3/JDBC3Statement.java
@@ -8,14 +8,14 @@
 import java.sql.SQLWarning;
 import java.sql.Statement;
 import java.util.Arrays;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 import org.sqlite.ExtendedCommand;
 import org.sqlite.ExtendedCommand.SQLExtension;
 import org.sqlite.SQLiteConnection;
 import org.sqlite.core.CoreStatement;
 import org.sqlite.core.DB;
 import org.sqlite.core.DB.ProgressObserver;
+import org.sqlite.util.Logger;
+import org.sqlite.util.LoggerFactory;
 
 public abstract class JDBC3Statement extends CoreStatement {
 
diff --git a/src/main/java/org/sqlite/util/Logger.java b/src/main/java/org/sqlite/util/Logger.java
new file mode 100644
index 000000000..78168e080
--- /dev/null
+++ b/src/main/java/org/sqlite/util/Logger.java
@@ -0,0 +1,18 @@
+package org.sqlite.util;
+
+/** A simple internal Logger interface. */
+public interface Logger {
+    boolean isTraceEnabled();
+
+    void trace(String format, Object o1, Object o2);
+
+    void info(String format, Object o1, Object o2);
+
+    void warn(String msg);
+
+    void error(String message, Throwable t);
+
+    void error(String format, Object o1, Throwable t);
+
+    void error(String format, Object o1, Object o2, Throwable t);
+}
diff --git a/src/main/java/org/sqlite/util/LoggerFactory.java b/src/main/java/org/sqlite/util/LoggerFactory.java
new file mode 100644
index 000000000..cdcb63ec4
--- /dev/null
+++ b/src/main/java/org/sqlite/util/LoggerFactory.java
@@ -0,0 +1,130 @@
+package org.sqlite.util;
+
+import java.text.MessageFormat;
+
+/**
+ * A factory for {@link Logger} instances that uses SLF4J if present, falling back on a
+ * java.util.logging implementation otherwise.
+ */
+public class LoggerFactory {
+    static final boolean USE_SLF4J;
+
+    static {
+        boolean useSLF4J;
+        try {
+            Class.forName("org.slf4j.Logger");
+            useSLF4J = true;
+        } catch (Exception e) {
+            useSLF4J = false;
+        }
+        USE_SLF4J = useSLF4J;
+    }
+
+    /**
+     * Get a {@link Logger} instance for the given host class.
+     *
+     * @param hostClass the host class from which log messages will be issued
+     * @return a Logger
+     */
+    public static Logger getLogger(Class<?> hostClass) {
+        if (USE_SLF4J) {
+            return new SLF4JLogger(hostClass);
+        }
+
+        return new JDKLogger(hostClass);
+    }
+
+    private static class JDKLogger implements Logger {
+        final java.util.logging.Logger logger;
+
+        public JDKLogger(Class<?> hostClass) {
+            logger = java.util.logging.Logger.getLogger(hostClass.getCanonicalName());
+        }
+
+        @Override
+        public boolean isTraceEnabled() {
+            return logger.isLoggable(java.util.logging.Level.FINEST);
+        }
+
+        @Override
+        public void trace(String format, Object o1, Object o2) {
+            if (logger.isLoggable(java.util.logging.Level.FINEST)) {
+                logger.log(java.util.logging.Level.FINEST, MessageFormat.format(format, o1, o2));
+            }
+        }
+
+        @Override
+        public void info(String format, Object o1, Object o2) {
+            if (logger.isLoggable(java.util.logging.Level.INFO)) {
+                logger.log(java.util.logging.Level.INFO, MessageFormat.format(format, o1, o2));
+            }
+        }
+
+        @Override
+        public void warn(String msg) {
+            logger.log(java.util.logging.Level.WARNING, msg);
+        }
+
+        @Override
+        public void error(String message, Throwable t) {
+            logger.log(java.util.logging.Level.SEVERE, message, t);
+        }
+
+        @Override
+        public void error(String format, Object o1, Throwable t) {
+            if (logger.isLoggable(java.util.logging.Level.SEVERE)) {
+                logger.log(java.util.logging.Level.SEVERE, MessageFormat.format(format, o1), t);
+            }
+        }
+
+        @Override
+        public void error(String format, Object o1, Object o2, Throwable t) {
+            if (logger.isLoggable(java.util.logging.Level.SEVERE)) {
+                logger.log(java.util.logging.Level.SEVERE, MessageFormat.format(format, o1, o2), t);
+            }
+        }
+    }
+
+    private static class SLF4JLogger implements Logger {
+        final org.slf4j.Logger logger;
+
+        SLF4JLogger(Class<?> hostClass) {
+            logger = org.slf4j.LoggerFactory.getLogger(hostClass);
+        }
+
+        @Override
+        public boolean isTraceEnabled() {
+            return logger.isTraceEnabled();
+        }
+
+        @Override
+        public void trace(String format, Object o1, Object o2) {
+            logger.trace(format, o1, o2);
+        }
+
+        @Override
+        public void info(String format, Object o1, Object o2) {
+            logger.info(format, o1, o2);
+        }
+
+        @Override
+        public void warn(String msg) {
+            logger.warn(msg);
+        }
+
+        @Override
+        public void error(String message, Throwable t) {
+            logger.error(message, t);
+        }
+
+        @Override
+        public void error(String format, Object o1, Throwable t) {
+            logger.error(format, o1, t);
+        }
+
+        @Override
+        public void error(String format, Object o1, Object o2, Throwable t) {
+            logger.error(format, o1, o2, t);
+        }
+    }
+}
diff --git a/src/main/java/org/sqlite/util/OSInfo.java b/src/main/java/org/sqlite/util/OSInfo.java
index abf9d1c72..05f279068 100644
--- a/src/main/java/org/sqlite/util/OSInfo.java
+++ b/src/main/java/org/sqlite/util/OSInfo.java
@@ -31,8 +31,6 @@
 import java.util.HashMap;
 import java.util.Locale;
 import java.util.stream.Stream;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
 
 /**
  * Provides OS name and architecture name.
diff --git a/src/test/java/org/sqlite/architecture/CodingRulesTest.java b/src/test/java/org/sqlite/architecture/CodingRulesTest.java
index 2bc3aa78f..6e17b9026 100644
--- a/src/test/java/org/sqlite/architecture/CodingRulesTest.java
+++ b/src/test/java/org/sqlite/architecture/CodingRulesTest.java
@@ -1,6 +1,7 @@
 package org.sqlite.architecture;
 
 import static com.tngtech.archunit.base.DescribedPredicate.not;
+import static com.tngtech.archunit.core.domain.JavaClass.Predicates.belongToAnyOf;
 import static com.tngtech.archunit.core.domain.JavaClass.Predicates.equivalentTo;
 import static com.tngtech.archunit.lang.conditions.ArchPredicates.are;
 import static com.tngtech.archunit.lang.syntax.ArchRuleDefinition.noClasses;
@@ -14,15 +15,26 @@
 import com.tngtech.archunit.core.importer.ImportOption;
 import com.tngtech.archunit.junit.AnalyzeClasses;
 import com.tngtech.archunit.junit.ArchTest;
+import com.tngtech.archunit.lang.ArchCondition;
 import com.tngtech.archunit.lang.ArchRule;
 import com.tngtech.archunit.lang.conditions.ArchConditions;
 import java.sql.DriverManager;
+import org.sqlite.util.LoggerFactory;
 import org.sqlite.util.OSInfo;
 
 @AnalyzeClasses(
         packages = "org.sqlite",
         importOptions = {ImportOption.DoNotIncludeTests.class})
 class CodingRulesTest {
+    public static final ArchCondition<JavaClass> USE_SLF4J_LOGGING;
+
+    static {
+        USE_SLF4J_LOGGING =
+                ArchConditions.dependOnClassesThat(
+                                com.tngtech.archunit.core.domain.JavaClass.Predicates
+                                        .resideInAPackage("org.slf4j"))
+                        .as("use SLF4J");
+    }
 
     @ArchTest
     void no_access_to_standard_streams(JavaClasses importedClasses) {
@@ -35,7 +47,12 @@ void no_access_to_standard_streams(JavaClasses importedClasses) {
 
     @ArchTest private final ArchRule no_jodatime = NO_CLASSES_SHOULD_USE_JODATIME;
 
-    @ArchTest private final ArchRule no_java_util_logging = NO_CLASSES_SHOULD_USE_JAVA_UTIL_LOGGING;
+    @ArchTest
+    private final ArchRule no_loggers_except_ours =
+            noClasses()
+                    .that(not(belongToAnyOf(LoggerFactory.class)))
+                    .should(USE_JAVA_UTIL_LOGGING)
+                    .orShould(USE_SLF4J_LOGGING);
 
     @ArchTest
     private final ArchRule no_driver_manager_println =