This paper presents a new fair queuing algorithm called Deficit Round Robin (DRR), which achieves nearly perfect fairness in terms of throughput while requiring only O(1) work to process a packet. The algorithm is simple and efficient, making it suitable for high-speed implementations. DRR is applicable to other scheduling problems where servicing cannot be broken into smaller units. Fair queuing is a technique that ensures each flow passing through a network device receives a fair share of network resources. Previous fair queuing schemes required O(log(n)) work per packet, which is expensive at high speeds. Cheaper approximations of fair queuing, however, can exhibit unfair behavior. DRR addresses this by using a combination of source hashing and deficit round-robin scheduling. Source hashing is used to map incoming packets to corresponding queues, reducing the cost of lookups. Deficit round-robin scheduling avoids the unfairness of traditional round-robin scheduling by keeping track of the "deficit" or past unfairness for each flow. This allows queues that were shortchanged in one iteration to be compensated in the next. The algorithm ensures that each flow receives a fair share of bandwidth, with the fairness index approaching 1. The work complexity is O(1), making it efficient for high-speed implementations. The paper also discusses the performance and bounds of DRR, showing that the difference between the ideal and actual allocation to a flow is bounded by the size of a maximum-size packet. This ensures that the fairness index of all flows is 1 in the heavy traffic scenario. The paper evaluates DRR and compares it with existing fair queuing algorithms, showing that DRR achieves nearly perfect fairness with low work complexity. The algorithm is applicable to various scheduling problems and is suitable for implementation in hardware.This paper presents a new fair queuing algorithm called Deficit Round Robin (DRR), which achieves nearly perfect fairness in terms of throughput while requiring only O(1) work to process a packet. The algorithm is simple and efficient, making it suitable for high-speed implementations. DRR is applicable to other scheduling problems where servicing cannot be broken into smaller units. Fair queuing is a technique that ensures each flow passing through a network device receives a fair share of network resources. Previous fair queuing schemes required O(log(n)) work per packet, which is expensive at high speeds. Cheaper approximations of fair queuing, however, can exhibit unfair behavior. DRR addresses this by using a combination of source hashing and deficit round-robin scheduling. Source hashing is used to map incoming packets to corresponding queues, reducing the cost of lookups. Deficit round-robin scheduling avoids the unfairness of traditional round-robin scheduling by keeping track of the "deficit" or past unfairness for each flow. This allows queues that were shortchanged in one iteration to be compensated in the next. The algorithm ensures that each flow receives a fair share of bandwidth, with the fairness index approaching 1. The work complexity is O(1), making it efficient for high-speed implementations. The paper also discusses the performance and bounds of DRR, showing that the difference between the ideal and actual allocation to a flow is bounded by the size of a maximum-size packet. This ensures that the fairness index of all flows is 1 in the heavy traffic scenario. The paper evaluates DRR and compares it with existing fair queuing algorithms, showing that DRR achieves nearly perfect fairness with low work complexity. The algorithm is applicable to various scheduling problems and is suitable for implementation in hardware.